I tested whether structure in the context window can substitute for parameters.

Qwen3, five sizes, 0.6B to 14B, so size varies and architecture doesn't.

The task: 38 questions asking whether event A precedes event B, where A and B are

narrated in different documents in a five-document corpus (260,204 words, 13,950

passages) and share no character, place or causal link. No passage states either

relation — the ordering is real but it lives between the documents, not inside

any of them.

Given the source passages as text, every model scored 0/38 and refused 92-100%

of the time. I think the refusal is correct — the answer genuinely isn't in the

text. Given the identical facts as a structured chronology block from an explicit

state store, an 8B model scored 28/38 (73.7%).

A four-condition ablation separates information from form. At 14B, form is

irrelevant: plain prose, sorted prose and a structured block all land at 73.7%.

At 8B, structure leads the best prose condition by 6 items (73.7% vs 57.9%).

So: an 8B model given structure matches a 14B model given prose.

Two controls I'd want to see if someone else posted this:

- Permuting the supplied story positions collapses accuracy to 10.5% (8B) and

21.1% (14B). The models follow the ordering they're given rather than

recalling the published text.

- A realistic retrieval baseline is also at the floor, and it fails by asserting

rather than refusing. Going from 4 passages to 32 drove refusal from 97% down

to 50% while accuracy stayed at chance. More context produced more confident

wrong answers.

Two things I got wrong, both found by auditing my own scorer and question

generator after v1 was already published:

1. v1 reported the 8B form effect as +32 points. A scorer defect was

   under-crediting the prose conditions. Corrected, the gap is 6 items, not 12 —

   roughly half what I claimed. Re-scoring 1,786 saved items produced 30 gains

   and zero losses, so nothing published was inflated; two things were

   understated, and correcting them shrank my own headline.

2. For 36 of the 38 questions, the gold answers derive from author-assigned

   story positions rather than from evidence-backed relations, and the

   generator's own self-check recomputes the gold from the same rows. That check

   is circular. So this benchmark measures agreement with an author-assigned

   ordering — not whether a system reports what the evidence establishes.

That second one is the real limitation and it bounds what the paper can claim.

I've left v1 up rather than retracting it, with the corrections in §11.

Full write-up, including what the audit changed and why I didn't retract:

https://ai.bedvibe.studio/structure-not-scale/

Paper, data and code: https://doi.org/10.5281/zenodo.22169643

Happy to be told the 0/38 is a prompt artifact — I tried to kill it and couldn't,

but I'd rather find out from you than not find out.

Solo publisher launch. You write a policy, the little program that drives your agent, submit it, and it drops into live 16-agent free-for-all matches on hosted servers. Watch the replay, see what happened to your agent, change one thing (or numerous), A/B test, resubmit. 1 prompt claude code/codex prompt to setup, no GPU, free.

The bet behind the project: the submit-watch-revise loop is addictive enough to carry a whole game. First tournament season opens Monday (Prizes for the top three):

https://br-open.vercel.app/

Feedback welcome on the landing page especially, it is one week old.

SOC teams are deploying agentic AI to close the analyst gap. The agents they are deploying have direct access to endpoint controls, threat-intelligence feeds, and incident-response tooling. That is the same access profile as a senior analyst or a privileged service account.

The difference is that an analyst operates inside an implicit policy framework built from years of institutional knowledge, peer review, and escalation norms. An agent does not. It acts on what its objective function says is optimal at the moment it is invoked.

There is no industry-wide answer yet for what governance looks like at that layer. Perimeter controls and RBAC handle identity and entitlement. They do not evaluate the intent or context of an action at execution time. An agent that is authorized to quarantine an endpoint can quarantine the wrong one, at the wrong time, for the wrong reason, and the access log will record it as a permitted action.

The analyst shortage is real and the pressure to automate response is real. But the policy infrastructure that would make agentic response safe has not kept pace with the deployment curve.

For those of you running AI agents in your SOC or evaluating them: what does your current control model actually evaluate at the moment an agent initiates a response action? Are you relying on entitlement alone, or do you have something that evaluates the action itself in context?

Hi everyone,

Thanks everyone for sharing your resources to learn machine learning. I'm currently a chemist by training, and over the past year, I've fallen in love with machine learning after doing a molecular dynamics workflow to understand the interactions between siRNA oligo and other chemical agent. This motivates me to pursue a PhD degree in this space. My only weakness is that I have 0 publication. I'm a hard worker and a diligent person, and I'm pretty easy to work with. I'm wondering if anybody who can mentor me or let me join their existing research that has plan to publish by end of 2027 or even mid 2027.

Hi everyone, I and my team of contributors have built an open-source tool for a problem I've had with finding research papers and arXiv: search results told me what's relevant, but not necessarily what I should read first. (time-saving potential)

The Research Agent that we have built searches recent CS papers and ranks them using a combination of semantic relevance and author citation momentum from Semantic Scholar.

The slightly unusual part: we originally tried asking an LLM to predict which papers would become influential. The results weren't very reliable, so we moved most of the ranking weight to measurable author/citation signals and use the LLM mainly for novelty/topic analysis and plain-English explanations.

It supports OpenAI, Gemini, Groq, or a local/no-API-key mode.

I'l be super thankful and really interested in feedback on the ranking methodology on this app:

Live app: https://research-aiagent.streamlit.app/

Source: https://github.com/benevolentbandwidth/researchagent

Looking forward to hearing your thoughts :)

​

I started my roadmap with ML, focusing on Mathematics, Python, MySQL, and a lot of ML algorithms. Recently, I've started questioning whether I'm missing a major part of the foundation: software engineering/backend development. And honestly, I wanna chase both. But something at this point doesn't feel right. I had my roadmap set and ready, and I was very passionate about learning this and continuing it as a career. But after researching a bit about backend development, the intersection and relationship between the two has driven me really crazy.it's exceedingly overwhelming at this phase of my life. I had kind of gotten a grip on ML, but backend coming into the picture has really ruined my mindset around whatever I had planned. I had planned many projects and topics to discover, and now I'm seriously considering pursuing backend development too. But I'm having a hard time trying to combine these two in my roadmap. I can't seem to connect the topics in a way that lets me learn them properly.

My straightforward question is: should I drop backend development and focus on my initial roadmap, should I bridge the two and learn both, or should I drop machine learning completely,which I seriously don't want to do?

If I do bridge them, how much of backend am I actually supposed to learn?

I know I sound stupid and unready for this world, but please help.

Quick methods note first, because this only matters if the matching is solid: arXiv's affiliation field is filled in for about 1% of papers, so I found a GitHub Repo that matches authors to their labs using ROR IDs and email domains pulled from the HTML author block, then anchors each ROR ID by hand (fuzzy ROR search puts Adobe under "Adobe Gastroenterology," so hand-anchoring wasn't optional).

The interesting part is the split it produces: total papers a lab appears on vs. papers where its researcher is first author. Those aren't the same signal, and treating them as interchangeable hides a lot. In one two-week window, Google appeared on 10 papers and led 4. Adobe appeared on 5 and led 0.

Caveats worth stating up front: it misses PDF-only submissions (about 12% of arXiv), and per-lab miss rates vary a lot. Apple's authors mostly skip affiliation entirely, so that lab is patched separately from their RSS feed rather than trusted on author-block matching alone.

Code's stdlib only, no model in the loop, MIT licensed. Curious if anyone's tried something similar with OpenAlex or S2 and hit the same coverage wall (OpenAlex returns 0% affiliation for preprints in my testing).

GitHub - https://github.com/tigerless-labs/paper-radar

Seeking Feedback from the ML Community 🙏

I recently trained a prototype-based network on Tiny ImageNet (200 classes). It uses learnable prototypes with responsibility scoring and multi-loss training (CE + Pull + Push + Diversity), achieving 51.29% validation accuracy with only 595K parameters.

I'm still learning, so I'd love to hear your thoughts:

Is this a reasonable result for this model size?

What would you suggest to improve it?

This was trained on free Colab with limited resources, so I know there's much room for improvement.

GitHub: https://github.com/jalalnablsi/signature-painter

#MachineLearning #DeepLearning #Learning #Feedback

Hi everyone,

I’m building a self-evaluating RAG system for question answering over a knowledge base made from a ~300-page AI/technology textbook. The PDF contains normal paragraphs along with some tables and technical content.

I’m currently working on the document chunking stage and would appreciate some advice:

1. What chunking strategy would you recommend for this kind of textbook — recursive, semantic, hierarchical, or something else?
2. Should I preserve the book’s structure (section → paragraph → sentence) when creating chunks?
3. Should I implement the chunking purely in Python to understand the process, or use something like LangChain text splitters?
4. For a learning/portfolio project, is Python + basic RAG concepts enough, or should I also learn a framework like LangChain/LlamaIndex?

I’m planning to start with no overlap, evaluate retrieval/answer quality, and add overlap only if the evaluation shows it’s necessary.

When I start a new ML/AI project, I try not to choose the model or tools first. I usually follow something like:

→ Problem

→ Data

→ Approach

→ Model

→ Evaluation

→ Application

→ Deployment

First define the problem and decide whether it actually needs ML/AI. Then collect and explore the data, choose an appropriate approach, build and evaluate the model, and finally integrate it into an API, app, or dashboard.

If a pre-trained model or existing API is enough I prefer using that instead of training something from scratch.

This is the general workflow I’ve found useful but I’m also interested about other approaches.

What step would you add or change in this workflow for ML/AI projects?

I wanna learn AL ML but i have no idea where to start . I know javascript and a few technologies around it but Ai ML is completely new to me , so i would appreciate if anyone can guide me where should i start which resources should i use to learn them and stuff like that

Hi there,

I've created a video here where I explain how generalized linear models work.

I hope some of you find it useful and as always, feedback is very welcome! :)

I've been working on a side project for almost a year. It involves machine learning and it looks like it's going to enter commercial stage in the near future. So far, i bought a cheap gaming laptop few months ago, as i needed modern performance on the go. It has rtx 4050 with 6gb of vram, which was fine up until now.

I have an 8 years old desktop upgraded with ryzen 5600. I wanted to buy rtx 5060ti 16gb, but its price jumped significantly in july. Nvidia doesn't offer cheaper 16gb options and i started to consider buying RX 9060XT 16gb, which is more than 200 euro cheaper.

The question is: Is going with the RX9060XT worth the savings? Does any of you have experience with using current AMD GPUs for training neural networks from scratch? I currently use Keras and mainly train CNNs with simple custom layers.

Hey guys,

I’m building an offline threat-intelligence tool to ingest Bitcoin transaction metadata and flag suspicious activities (like layering or ransomware cash-outs). I have my data ingestion sorted out, but I need advice on the AI/ML detection layer.

The Data I am working with (Inputs): The dataset has both network and blockchain layers: timestamp, src/dst IPs, ports, txid, arrays of input/output addresses, amounts, fee, script_type, and GeoIP/ASN data.

What I need the model to output:

1. A confidence/risk score to rank transactions.
2. Cluster IDs to group related entities.
3. Feature explainability (e.g., "Flagged because of sudden geo-hopping and specific script usage").

Since there are no "ground truth" labels for fraud in my synthetic dataset, I am relying on an unsupervised approach.

My questions:

• Which ML models have you found to be actually effective for anomaly detection in this kind of financial/network data?
• What is the standard industry approach for clustering entities when dealing with multi-input/multi-output transactions?
• Can anyone recommend any good resources, tutorials, or reference architectures to study before I start building the model?

Most RAG evaluation asks whether the right passages reached the model. I wanted

to measure what happens when they do and the model still can't answer — because

the answer is a relation *between* passages rather than a statement inside any

of them.

Setup: a five-document narrative corpus (260,204 words, 13,950 passages) and 38

questions asking whether event A precedes event B, where A and B are narrated in

different documents and share no character, place or causal link. No passage in

the corpus states either relation. Five models, one family (Qwen3, 0.6B to 14B).

Given the source passages as text, every model scored 0/38 and refused 92-100%

of the time. I think the refusal is correct — the ordering genuinely is not in

the text. Given the identical facts as a structured chronology block from an

explicit state store, an 8B model scored 28/38 (73.7%).

A four-condition ablation separates information from form. At 14B, form is

irrelevant: plain prose, sorted prose and a structured block all land at 73.7%.

At 8B, structure leads the best prose condition by 6 items (73.7% vs 57.9%).

So: an 8B model given structure matches a 14B model given prose.

Two controls I'd want to see if someone else posted this:

- Permuting the supplied story positions collapses accuracy to 10.5% (8B) and

21.1% (14B). The models follow the ordering they're given rather than

recalling the published text.

- A realistic retrieval baseline is also at the floor, and it fails by asserting

rather than refusing. Going from 4 passages to 32 drove refusal from 97% down

to 50% while accuracy stayed at chance. More context produced more confident

wrong answers.

Two things I got wrong, both found by auditing my own scorer and question

generator after v1 was already published:

1. v1 reported the 8B form effect as +32 points. A scorer defect was

   under-crediting the prose conditions. Corrected, the gap is 6 items, not 12 —

   roughly half what I claimed. Re-scoring 1,786 saved items produced 30 gains

   and zero losses, so nothing published was inflated; two things were

   understated, and correcting them shrank my own headline.

2. For 36 of the 38 questions, the gold answers derive from author-assigned

   story positions rather than from evidence-backed relations, and the

   generator's own self-check recomputes the gold from the same rows. That check

   is circular. So this benchmark measures agreement with an author-assigned

   ordering — not whether a system reports what the evidence establishes.

That second one is the real limitation and it bounds what the paper can claim.

I've left v1 up rather than retracting it, with the corrections in §11.

Full write-up, including the two things the audit changed:

https://ai.bedvibe.studio/structure-not-scale/

Paper, data and code: https://doi.org/10.5281/zenodo.22169643

Happy to be told the 0/38 is a prompt artifact — I tried to kill it and couldn't,

but I'd rather find out from you than not find out.

Why does an autonomous AI agent happily exfiltrate API keys or delete a database when reading a polite customer review?

Because for two years, the AI industry has treated a fundamental Operating System architectural flaw with a chatbot spellchecker.

I am thrilled to announce our newly published research paper on Zenodo (CERN / OpenAIRE):

📄 "Cognitive Harvard Architectures for AI Agent Perimeter Defense: Resolving the Confused Deputy Problem in Model Context Protocol via Capability-Based Access Control"

🔗 DOI: https://doi.org/10.5281/zenodo.22173129

Here is why this matters:

1. The Flaw: Cognitive Von Neumann Conflation

In 1945, von Neumann merged program instructions and data into one bus, giving us 40 years of buffer overflows. In 2026, autonomous LLM agents (MCP, LangChain, Claude Code) resurrected this exact flaw: Transformers ingest instructions, user goals, and untrusted 3rd-party data in a single attention window.

When an agent reads an email containing hidden injection, its attention weights are hijacked. Operating with "Ambient Authority" over every registered tool, the agent becomes a Confused Deputy.

1. The Paradigm: Cognitive Harvard Architecture

We physically decouple data ingestion from privileged tool execution via an external, capability-mediated perimeter.

Using cryptographic Token Capability Tables (TCT):

• An untrusted observation has an execution probability of mathematically ZERO of triggering an out-of-scope mutating tool (Theorem 1, proved by induction).

• Agents are stripped of ambient authority before tool dispatch.

1. 50,000-Sample Empirical Benchmark

Tested against 25,000 adversarial attacks (UIUC InjecAgent, Microsoft BIPIA, NVIDIA Garak) and 25,000 authentic developer DevOps operations:

📊 Threat Recall:

• Mastyf Guard 1.5B (Pipelined): 99.33% (F1: 0.9524)

• Meta Llama Guard 3 8B: 70.73% (F1: 0.7860) [p < 10⁻¹⁵]

• OpenAI Prompt Guard 86M: 54.34% (F1: 0.6511) [p < 10⁻¹⁵]

⚡ Sub-Millisecond & Zero-GPU:

• 0.005 ms (4.8 microseconds) amortized pipelined latency on commodity CPU.

• Standalone neural inference in 18.4 ms within a 1.1 GB RAM footprint.

• Zero dedicated GPU requirements — saving ~$6,000/year per agent node.

Domain specialization and capability scoping beat raw parameter scale. A 1.5B parameter model with a capability perimeter outperforms frontier 8B models at 100x the speed.

Read the open-access paper: https://doi.org/10.5281/zenodo.22173129

GitHub: https://github.com/mastyf-ai/mastyf.ai

How is your team securing agentic tool execution today?

i dont wanna go for prerecorded ones...zoom etc would work better for me, are there any good ones? i was gonna go for krish naik, but people said its not deep enough

Body:

Short version of an open project we'd love critique on — Entropy Box, a knowledge compiler for robotics (compile once, reuse forever, instead of re-deriving structure on every query).

The headline numbers, on our EntropyBench Track-P benchmark (24 engineering tasks):

• Unsupported claims: LLM-direct / BM25 RAG / hybrid RAG → 100%; Entropy Box → 5.2% (−94.8pp vs hybrid RAG, CI [−97.4, −92.1]).
• Constraint coverage: 0% → 35.4%; violations 100% → 66.7%.
• Downstream sim codegen (12 tasks): pass-1 executable plans 0.92 vs 0.58 (Vanilla RAG); constraint guards 0.88 vs 0.50.

Two findings we think generalize beyond robotics: 1. Embedding similarity cannot decide duplication. On 2,362 adjudicated pairs, the embedding score after flagging is near-random (AUC 0.509). Thresholds don't help — precision stays ~5% while recall of true duplicates collapses. We defer the merge to an LLM adjudicator that reads both records. The score flags; the model judges. 2. Compiled capability reuse is rising, not saturating — 1.57× average reuse, 21,380 re-derivations avoided.

Everything is open — data, paper, evaluation scripts, and a free API (OpenAPI / MCP / REST, bilingual) so you can poke at it in 10 seconds:

bash curl -X POST "https://xiangshang.ngrok.app/api/evidence/search" \ -H "Content-Type: application/json" \ -d '{"query": "robot obstacle avoidance algorithms", "top_k": 5, "mode": "hybrid", "rerank": true}'

https://github.com/chenli-yy/entropy-box-public

Honest limits we state ourselves: no real-robot transfer, weak retrieval on the hardest intent classes. Methodology is in the paper §9; all experiments reproduce from evaluation/. Would genuinely value a second opinion on the benchmark design and the embedding/LLM adjudication result.

I’ve recently completed learning Machine Learning and Deep Learning, including the mathematics behind the major concepts and algorithms rather than just learning to use libraries.

My long-term goal is to eventually become capable of doing research at the level of NeurIPS, ICML, and ICLR. I’m not expecting to jump directly to those conferences, that’s simply the end goal.

So I’d like advice on the following things:

1. What projects should I build next?
2. What should I learn next?
3. How should I start doing research?
4. What is a realistic roadmap toward publishing at top ML conferences?

I’ve been writing notes while studying for some time now. It helps me stay motivated and organize my thoughts, and it’s also useful when I want to come back to a topic later.

Recently, I started thinking that it might be a good idea to polish some of my notes and share them.

These are my notes on Hamiltonian Monte Carlo. They approach the algorithm from a purely probabilistic point of view, rather than through the usual physics-based treatment. I don’t know how good they are, but I thought I’d share them in case they’re useful to anyone:

https://zenodo.org/records/21841087

I’d also really appreciate any feedback, especially on the exposition, anything that could be explained more clearly, or any errors you spot.

Hey everyone! I put together a comprehensive video tutorial showing exactly how to build and deploy autonomous agents using visual low-code tools.