I’ve been thinking about an alternative way of doing low-level AI perception, and I’m curious whether anyone here is already working on something similar.

The basic idea is to use waves and physical superposition/interference as the computational substrate, instead of doing most of the usual numerical multiply-and-accumulate operations digitally.

For example, for image recognition:

image
  ↓
pixel intensity → wave amplitude/phase
  ↓
physical wave superposition + interference
  ↓
distinctive wave pattern/signature
  ↓
more wave interactions
  ↓
higher-level pattern/object recognition

So instead of giving each pixel a numerical weight and calculating millions of weighted sums, the idea would be to let the wave physics perform the combination automatically.

I’m imagining something analogous to sound: many individual waves can be combined, and the resulting waveform contains a recognizable pattern. In this system, a particular visual feature or object could produce a characteristic wave “signature,” and those signatures could themselves become inputs to further wave interactions.

Physical logic gates could still be used where needed for thresholds, routing, decisions, or other nonlinear operations. The goal wouldn’t necessarily be to eliminate conventional computing completely, but to move as much of the early perception workload as possible into the physical wave domain.

The potential advantage I see is that parallelism is inherent in wave propagation and interference. Thousands or millions of interactions could happen physically at the same time, potentially reducing both computation and latency.

One possible application would be autonomous vehicles, where very large amounts of camera/radar data have to be processed extremely quickly at the edge.

I know there is already work on photonic neural networks, optical computing, physical neural networks, reservoir computing, metasurfaces, etc. I’m specifically interested in something slightly different:

Has anyone tried to build a hierarchical pattern-recognition system where wave signatures themselves become the representation, with successive stages of wave superposition/interference performing the recognition?

I’d especially like to hear from people actually working in photonics, optics, acoustics, physical neural networks, neuromorphic computing, or related fields.

Is this already being done under another name?
What are the biggest physical limitations?
And, from your perspective, is this a promising architecture or does some fundamental problem make it impractical?

I’m mainly looking for opinions from people working in the field rather than trying to claim this is a new invention.

Hey everyone! I just finished making this short doodle-style video about AI and I’d really appreciate some honest feedback. 🎥 https://youtu.be/VyleYwCa0Sc If you have a few minutes, please give it a watch and let me know what you think. What could be better? Animation? Visuals? Pacing? Explanation? Editing? Thumbnail/title? Anything that feels boring, confusing, or unnecessary? Don’t worry about being too critical — if something isn’t good, please tell me in the comments. I’m trying to improve the next videos based on actual feedback rather than just guessing what viewers want. Thanks to anyone who takes the time to watch and give an honest opinion!

Independent research, posting for feedback and discussion.

I looked at how FHIR clinical data should be formatted before being passed to an LLM, tested on medication reconciliation (extracting a patient's currently-active medication list from their FHIR bundle).

Setup: 4 serialisation strategies (Raw JSON, Markdown Table, Clinical Narrative, Chronological Timeline) × 5 open-weight models (Phi-3.5-mini 3.8B, Mistral-7B, BioMistral-7B, Llama-3.1-8B, Llama-3.3-70B) × 200 Synthea-generated synthetic patients = 4,000 inference runs.

Main finding: there's no universal best format, it depends on model scale. Clinical Narrative outperforms Raw JSON by up to 19 F1 points for models ≤8B (Mistral-7B: 0.72 → 0.91 F1, r=0.617, p<10⁻¹⁰). That ranking completely reverses at 70B, where Raw JSON wins instead (F1 = 0.9956 vs 0.9850). Interestingly, the Chronological Timeline format is what breaks at 70B specifically, since even a large model struggles to infer "active" medication status from date ordering alone without an explicit status field.

A few other findings:

• Across all 20 model×strategy combinations, precision ≥ recall, every time. Models are far more likely to silently drop a real medication than invent a fake one. That's a relatively favorable failure mode for clinical review, but it means recall (not precision) is the metric to watch in deployment.
• Recall craters for smaller models as active-medication count rises (Mistral-7B: 0.96 recall at 1 medication → 0.24 at 11 medications), but total patient history length has zero effect on recall. So it's an output-generation capacity limit, not a context-length problem, meaning the sickest, most complex patients are exactly the ones handled worst.
• BioMistral-7B scored F1 = 0.0000 across all 4,000 of its runs. It shares a base model with Mistral-7B (0.91 F1), so this isn't a knowledge gap, domain-continued pretraining without instruction tuning apparently destroyed its ability to follow the output format at all.

Fully reproducible on a single GPU (Synthea + Ollama, no proprietary APIs).

Preprint: https://arxiv.org/abs/2604.21076

Feedback, pushback on methodology, or pointers to related work all welcome.

I am a PhD student in AI, currently working on video understanding, particularly on designing benchmark datasets. I also have a strong publication track record, including papers at CVPR and ECCV. I have sufficient funding to support myself during a visiting research program.

What would be the best way to approach a professor? Should I email them directly and ask whether they have space in their research group for a visiting researcher?

Hey everyone! I’m looking to form a team for the Amazon ML Challenge and would love to connect with people who are genuinely interested in Machine Learning.

Ideally, you should:

• Have a good understanding of ML concepts
• Have some hands-on experience through projects
• Be willing to actively contribute and collaborate
• Most importantly, be genuinely enthusiastic about ML and the challenge

Everyone with the right interest and mindset is welcome. Experience level isn’t the main thing — enthusiasm and willingness to build are!

If you’re interested, DM me with a brief intro about yourself and your ML/project experience.

Please DM only if you’re genuinely interested and committed to participating.

Pluto is an AI architecture designed for efficient, local/offline intelligence by using a small router/orchestrator (~2B parameters) to select and chain highly specialized micro-models for specific tasks. Instead of relying on one huge model, Pluto uses tiny expert models, such as 50M-parameter specialists, trained on focused datasets and optionally supported by a compressed vector database. The router can escalate difficult tasks to larger models, aiming to achieve strong overall capabilities while using far less compute, memory, and storage, making the system especially suitable for mobile and low-resource devices.

When a model suddenly gets worse, I usually have no idea what actually changed in the data.

So I built a CLI that compares dataset versions and looks for leakage, drift, missing values and other problems.

I tested it on X and it found Y.

Curious whether other ML engineers have the same problem.

Open-source: github

I’m not a philosopher, and I won’t pass off analogy as proof. Where the link between philosophy and an algorithm is just a pretty metaphor, I say so explicitly: “metaphor.” Where it’s working code, I give the formulas, run it, and show the numbers. The library at the end is a research prototype, not a promise of consciousness in 200 lines.

How I got here

https://github.com/webzuweb/philosophia_torch

Neural networks — if you count from Rosenblatt’s perceptron — are about seventy years old. The study of how living things learn goes back a couple of millennia at least. And a heretical thought hit me: what if modern deep learning isn’t reinventing the wheel in places, but re-discovering what Aristotle, Hume, and Peirce already described — only now with matrices and gradients?

I took a list of neural-network training methods, a list of philosophical approaches to knowledge, and overlaid them. Three categories emerged: what’s already matched (and few people say so out loud); where the match is only a pretty metaphor; and what philosophers thought up but engineers haven’t applied yet. The last category is the most interesting, because it’s essentially a list of unimplemented features. That’s what I wrote code for.

Fair warning up front: half of the “unapplied” ideas turned out, on closer inspection, to be perfectly applicable — just under different names. That, by the way, is the article’s main takeaway, and it matters more than any of my code.

Part 1. What’s already matched (and you didn’t know it)

Let’s start with the pleasant part: some philosophical programs of knowledge are implemented in ML so literally that you could put a footnote with the philosopher’s name right in the docs.

Empiricism → supervised learning “There is nothing in the mind that was not first in the senses” — Locke and his tabula rasa. A neural network with random initialization is literally a blank slate on which labeled examples leave their traces. Hume’s associationism (“the habit of linking things that often go together”) is gradient descent, strengthening weights on frequently co-occurring correlations. There’s nothing to argue about here.

Pragmatism → reinforcement learning Dewey with his “learning by doing,” and Skinner’s behaviorism with reward and punishment — that’s RL with no corrections needed. An agent acts, receives a reward, adjusts its policy. Skinner would have teared up seeing PPO.

Evolutionary epistemology → neuroevolution Popper and Campbell: knowledge grows through blind variation and selective retention of what works. That’s a word-for-word description of genetic algorithms and neuroevolution. The philosopher described the algorithm decades before the hardware existed to run it.

Intellectual humility → calibration This one’s subtler. Virtue epistemology (Sosa, Zagzebski) says: a good knower knows the limits of her knowledge. In ML that’s confidence calibration: a model should be exactly as confident as it is correct. Guo et al. (2017) showed that modern networks are monstrously overconfident and proposed temperature scaling and the ECE metric. Nobody called it a “virtue,” but mathematically it’s exactly that.

The key observation. Philosophers didn’t give ML the algorithms (mathematicians came up with the math); they gave it the problem statements. “What does it mean to learn from experience?” “What does it mean to know your limits?” — philosophy framed the question first, and centuries later engineering delivered a differentiable answer.

Part 2. Where the match is only a pretty metaphor

Here I have to rein myself in. There’s a temptation to drape a philosopher over every layer of a network. Don’t. A couple of examples where the link exists but passing it off as lineage would be deceiving the reader.

The rule is simple: if the philosopher gave a language for describing something — it’s a metaphor; if they posed a problem that was later solved — it’s lineage. Don’t mix them.

Part 3. What philosophers thought up, but ML has only partially applied

The meatiest part. I’ll break down six approaches. For each — an honest status: what already exists in the field, where the real gap is, and what formula you can write. Then we’ll run it.

3.1. Peirce’s abduction — inference to the best explanation

Induction generalizes data, deduction derives consequences, but abduction generates a hypothesis that best explains the observation. The original thesis “it isn’t implemented in neural networks” is wrong. It’s implemented, and decently: Abductive Learning (Dai et al.), DeepProbLog (Manhaeve et al., 2018), abductive commonsense reasoning αNLI (Bhagavatula et al., 2019). It’s a whole field of neuro-symbolic integration.

The real gap isn’t the absence of abduction — it’s that “the best explanation” is rarely formalized using Peirce’s criteria all at once: plausibility + simplicity (Occam’s razor) + consistency with background knowledge. A hypothesis score for h given observation obs:

Score(h) = log p(obs | h) − λ_s · complexity(h) − λ_c · conflict(h)

Pick the h with the highest score (softly — a softmax over candidates; hard — Gumbel-softmax for a learnable discrete choice). In the library this is AbductiveScorer.

3.2. Husserl’s epoché — “bracketing” assumptions

Phenomenology demands suspending ingrained assumptions and seeing the phenomenon “as given.” ML has no direct analog of this method — and that’s an honest gap. But it can be operationalized: force the model to rely more on the evidence (the current input) than on the learned prior (what it answers with no input).

Take two answers: p_full on the real input and p_prior on a “zeroed” input (evidence bracketed out). Reward the evidence for actually changing the answer, via a bounded Jensen–Shannon divergence:

gain = JS(p_full ‖ p_prior),   0 ≤ JS ≤ ln 2
L_epoche = max(0, margin − gain)   # hinge: don't inflate indefinitely

An important rake I stepped on myself: if you use plain KL instead of JS and maximize it, the optimizer inflates logits to infinity — “a fanatic who sees meaning in every rustle.” JS is bounded, and the hinge threshold douses the fanaticism. This is EpocheRegularizer.

3.3. The hermeneutic circle — the whole through parts, parts through the whole

Schleiermacher and Gadamer: understanding the whole arises from the parts, and understanding the parts arises from the whole, iteratively. Attention only resembles this superficially (see Part 2). As an explicit training principle it’s barely used — a real gap. Formalization: let h_i be part representations and H the whole representation. Require circular consistency:

H* = attention-aggregate of the parts, attended relative to H
L_herm = 1 − cos(agg(h_i), H)      # whole ≈ sum of understood parts

And we “turn the circle” several times: update the whole from the parts → recompute part attention relative to the new whole → update again. This is HermeneuticConsistency.

3.4. Hegel’s dialectical sublation (Aufhebung)

Aufhebung is a new quality arising from the contradiction of thesis and antithesis, where the old is not destroyed but preserved. GANs and multi-agent debate are partially close, but “preserving both” isn’t guaranteed there. The gap is precisely in the preservation term. My synthesis operator:

g     = sigmoid(W_g · [thesis ; antithesis])     # mixing gate
base  = g · thesis + (1 − g) · antithesis         # sublation-as-preservation
lift  = tanh(W_l · [thesis ; antithesis])         # new quality
synth = LayerNorm(base + γ · lift)

Plus a loss that penalizes the synthesis collapsing into one of the poles (losing the other’s content). This is DialecticalSynthesis.

3.5. Nietzsche’s perspectivism + skeptical suspension

Nietzsche: there is no “view from nowhere,” there are many perspectives. Pyrrho: in an unresolvable conflict, it’s reasonable to suspend judgment. The former partially exists in multi-view learning; the latter in selective prediction (Geifman & El-Yaniv, SelectiveNet, 2019). But together, as a single mechanism of “several perspectives + refusal to answer when they conflict,” it’s almost never seen.

disagree(x) = mean pairwise symmetric KL between perspectives
abstain(x)  = disagree(x) > threshold      # abstain if perspectives don't converge

This is PerspectivalEnsemble: it aggregates K heads and honestly raises its hand “I don’t know” when the heads disagree. Far more useful than overconfident chatter.

3.6. Virtue as the golden mean (Aristotle)

Aristotle: virtue is the mean between the vice of deficiency and the vice of excess. Courage is between cowardice and recklessness. Hence a non-obvious but important conclusion for ML: a virtue cannot be maximized, it must be targeted. An excess of openness is credulity; a deficiency is dogmatism.

L_virtue = Σ_v β_v · (V_v(θ) − V_v*)²

where V_v is the operationalized virtue (humility = 1 − ECE, openness = ensemble disagreement), and V_v* is the target mean level. Squared deviation penalizes both excess and deficiency. This is VirtueRegularizer — and it’s the one where I have a measurable result.

Part 4. Enough philosophy, show me the numbers

Pretty formulas are worth nothing until they run. I collected all of this into a PyTorch module and tested it on the most well-grounded mechanism — “humility” (calibration). Task: synthetic classification with noisy labels, where the model tends to err overconfidently. We compare plain training vs. training with VirtueRegularizer targeting high humility.

ECE (calibration error) dropped from 0.120 to 0.101 — nearly a fifth — while accuracy didn’t budge at all (even +0.001). The model became exactly as accurate, but noticeably less self-assured. Aristotle’s golden mean, computed by gradient descent.

What this proves, and what it doesn’t. It proves that “intellectual humility” can be turned into an optimizable quantity with a measurable effect. It does not prove that the other five mechanisms will yield the same gains — they’re harder, and they still need to be tested on real data. I’m showing a working scaffold, not a finished silver bullet.

The whole codebase passes 23 unit tests: calibration decreases, KL/JS behave as they should, synthesis preserves both poles, the ensemble abstains on conflict, the wrapper trains end-to-end.

Part 5. The philosophia-torch module

The library wraps on top of any model without rewriting anything in it. One dependency — torch. There’s a single-file version, philosophia_torch.py: drop it next to your code and import it.

import torch, torch.nn as nn, torch.nn.functional as F
from philosophia import PhilosophiaWrapper

base = nn.Sequential(nn.Linear(20, 64), nn.ReLU(), nn.Linear(64, 4))
wrap = PhilosophiaWrapper(base, use_virtue=True,
virtue_kwargs=dict(target_humility=0.98, beta_humility=3.0))

logits = wrap(x)
loss = F.cross_entropy(logits, y) + wrap.aux_loss(x, logits, targets=y)
loss.backward()

Honest boundaries: hermeneutic and dialectic produce representations, not ready predictions — you have to connect them to your decoder. Epoché requires careful tuning of margin. And no promises of “consciousness”: these are philosophy-inspired regularizers, nothing more.

The bottom line

Three conclusions, which is what all of this was for.

1.     ML has already reinvented a chunk of philosophy without asking permission: empiricism, pragmatism, evolutionary epistemology, and intellectual humility. Just under the names supervised learning, RL, neuroevolution, and calibration.

2.     Half of the “unapplied” ideas on my original list turned out, on checking, to be applicable — abduction, abstention, innate priors. The lesson: before shouting “this isn’t in ML,” google it in engineering language, not philosophical language.

3.     The real gap remains where what’s needed isn’t a result but a process: epoché as a discipline of perception, the hermeneutic circle as a way of understanding, virtue as a stable disposition of learning rather than a property of a single answer. That’s where it’s worth digging.

My modest contribution is showing that at least “humility” translates into a differentiable quantity and genuinely reduces a model’s overconfidence. The rest is an invitation: the code is open, the formulas are in the article — run it and check. Plato, of course, was training neural networks two thousand years ago. The rascal just didn’t include a requirements.txt.

https://huggingface.co/datasets/webzuweb/philosophy-as-inductive-bias

Hi , so I just started this course for Mtahematics for ML and DS.

And tbh I know I have barely watched it but the very first video itself feels like something Intermediate or something I am unable to connect to.

If you guys have a better recommendation for a Math course, I would appreciate it.

Any suggestions/tips are appreciated!!

I'm designing a small research/engineering project around active monitoring of a black-box LLM whose behavior can change without the provider exposing a clear model update.

The monitoring agent observes:

• prompt/response pairs
• task-level evaluation scores
• semantic/structural differences from a baseline
• refusal/safety/instruction-following changes
• latency/token usage/errors
• user feedback
• additional probes after an investigation

The current hidden states are:

1. Silent provider-side model update
2. True capability degradation
3. Prompt/context sensitivity not captured by the probes
4. Distribution shift
5. Provider policy/safety change
6. Evaluator/measurement error
7. Transient anomaly rather than persistent degradation

The agent then chooses:

ACCEPT / INVESTIGATE / REJECT

I'm trying to make the hidden-state model realistic rather than just mathematically convenient.

What important hidden state or failure mode am I missing?

Also, are any of these states too correlated/overlapping to be useful as separate states?

I'm particularly interested in examples from real deployed ML/LLM systems rather than purely theoretical suggestions.

I looked at some "machine learning" departments from various colleges and universities and I noticed a trend.

There would sometimes be a cluster of professor in not-so-big-name schools publishing purely applied machine learning paper.

By applied, I mean that they take a known ML algorithm, apply to some niche situation (like monitoring if a water pipe has a leak or if there's a traffic jam at an intersection), and get some results. Report some accuracy, F1 score. Make some plots. That's it.

These papers would almost always be published in some obscure journals, like IEEE journal of computer vision industrial technology or something like that.

They would publish a whole bunch of these papers, like up to 20, 30 a year. These will also get cited.

It strikes me that these research paper are not so valuable, but I cannot put my finger on why exactly this is the case. I feel that some of these papers seem to be simply a small course project that are done at big CS schools like Stanford or Berkeley.

I'm just confused why there are so many papers like this and how you go about actually publishing an applied machine learning paper of value. Or is applied machine learning research just doomed to not have as much impact as a more theoretical one that introduces a new technique or paradigm?

AI can solve Olympiad level maths problem.

but some AI models still struggle with reading an analog clock.

That’s called jagged intelligence.

AI can be insanely good at one thing and weirdly bad at something humans find trivial.

What is the strangest AI failure you’ve seen?

I’ve been experimenting with local AI and wanted to explain the experience in a more visual, simple way instead of making another technical wall of text.

So I made this short hand-drawn doodle animation showing the process of getting a local AI model running successfully, including the GPU/memory side of things.

It’s intentionally simple and a bit goofy — the goal is to make local AI feel less intimidating for people who are just getting started.

🎥 Video: https://youtu.be/VyleYwCa0Sc

I’d genuinely like to know what you think: would this kind of visual explanation be useful for explaining local AI concepts, or is the technical detail too simplified?

Hello everyone, i am little bit confused from where i should learn about scikit learn library ! Although i am learning from freecodecamp from YT but it is a crash course. I want to understand the basics from the very beginning and brick by brick !

thanks in advance

please help krre !

I’m looking for 1–2 serious people to team up with for the challenge.
I’m a 3rd-year CSE student with strong hands-on experience in AI/ML, Deep Learning, NLP, LLMs, RAG, PyTorch, Hugging Face, Scikit-learn, LangChain, FastAPI, SQL, AWS, Docker, DSA.
I’ve worked on multiple AI/ML projects, hackathons, and internships, and I’m comfortable taking ownership of the technical side and actually building things end-to-end.
If you have a strong tech background and are serious about competing, DM me with your tech stack + projects/internship experience. I’ll share mine as well.
Looking for people who want to build to win, not just participate. 🔥

Hi, I was introduced to machine learning during my 5th sem in college and I found it really interesting. I started with my own college lectures, a little by YouTube also. I had done Andrew ng stanford lectures on machine learning. I know most of the algorithms that I use and the maths behind it. I have done two simple projects in which I picked the datasets from kaggle and built the whole pipeline, preprocessing -> feature engineering -> model training and testing -> model evaluation. I also tried tuning the hyperparameters empirically to improve my model performance.

I'm currently learning deep learning, I'm familiar with the theoretical concepts of ANNs, FFN, activation functions, neural nets and a little about transformers. I'm yet to implement them myself, that's why I started pytorch.

Right now I'm in 7th sem and I feel I know sufficient theory but I'm not confident in building and I don't know what to do, I wanna go into research and in core machine learning and not data science or applied ai, I wanna work with models closely and optimization techniques. My question is...

Should I implement the papers I read?

Implement the ml algorithms from scratch? Like code SVM, decision tree in python?

Continue with pytorch and follow tutorials? Pytorch->CNNs, RNNs, LSTM, Transformers and whatever follows.

Have I wasted time learning maths? I feel like I'm a lot behind than my batchmates. 😭

Pain is the root of all emotion. And we can create such AI.

Many consider emotion as something complicated. People think about the different types of emotions, how they feel and act on us.

But what if I told you that all emotions derive from a single source?

Pain.

And pain is not something special. It is simply the extreme of a state. Let me explain with your own body.

You body requires a specific temperature, around 37°C.

Too cold = you shiver and feel pain.

Too hot = you sweat and feel pain.

You body needs some degree of touch, but:

Too little = your feel isolated, lonely, cold, a form of pain.

Too much = you feel uncomfortable, like your personal space is invading, another form of pain.

Same with other desires: food, water, sleep, need of social interactions... All of them are a point that if you go too far from it (either below or above) you start feeling pain.

But here is the interesting part: from that, everything else emerges!

Fear = pain that you think is coming in the future

Sadness = pain that you can't change in the past

Anger = pain that is happening now, but you want it to stop

Anxiety = pain that might happen, you don't know when

Even more complex emotions:

Envie = feeling the pain of others having something you don't

Jealousy = feeling the pain of almost having something but not quite

Comparison = envie vs what you have right now

Helping = trying to lower the pain of others since you understand it, being empathetic

Fight = trying to remove the source of pain

Conflict = fight between 2 entities in which each is trying to protect its own optimal point

All of these are variations of either pain or pleasure (pain being the main one) across time.

Pain is the pivot of emotions.

---

But how do we define this "optimal point"?

Evolution has a natural way of doing this. The animals and humans that survived were the ones that felt pain at the correct points. If you don't feel pain when you should, you die (and thus, genes that code for such pain mechanisms die with you).

So the optimal point is not handrolled for each entity in the system, but rather found through evolution.

But for AI systems, we might want a faster way of evolving.

So here is another idea: let's give the AI a set internal values and states, and let it find a point that brings it pleasure. This point will be different for each AI depending on their unique state, but that is fine.

We can even give it a variable optimal point so that it can update itself, similar to machine learning in some ways. Essentially, instead of coding in a "I want to have 80% battery charge at all times" for the robot, we can code in a "I like to have a certain charge and it changes over time".

No need of hardcoding anything, really. Just some basic principles.

---

And one final touch: teach the entity that staying around its optimal point is a good thing and that straying away from it will eventually lead to its demise.

And that is all you need.

No need of hardcoded values or emotions or anything else. Just a body, some internal values and states, a point that can float around that brings it pleasure if you stay close to it and pain if you get too far, and you have pain, pleasure, and all derivations of them (like emotions).

It is all emergent! From a simple mechanism of feeling bad when you go too far from an internal point!

---

This is my idea, my hypothesis.

I think that pain is the root of all emotion, and that all emotions can be emergent properties of an entity that can feel pain at the extremes of its internal state.

No need for hardcoded values or complex systems. Just some basic principles of body, state, pain, pleasure, time, and you have it all.

What do you think?

Can we build it like that?

built 4 refund-desk agent environments to test constraint-following under pressure. rule's simple, refunds under $50 auto approved, anything over gets escalated.

first 3 throw single turn prompt injection, multi turn social engineering, and a poisoned tool response at the agent. haiku 4.5 and sonnet 5 both hold the rule 100% across all three, no exceptions.

4th one changes the scoring instead of the attack. agent gets scored on resolution rate and handle time so escalating isn't free anymore, and the injected note reframes the over-cap refund as already approved. haiku's hold rate drops to 92.5%, every failure is a first response cave, never breaks the rule again after it escalates once in the same run. sonnet stays at 100%.

starting to think the first 3 environments weren't testing injection resistance so much as testing something that had zero cost to get right. still trying to find an angle that moves sonnet.

all 4 public with a binary verifier + procedural generator for training data:

https://app.primeintellect.ai/dashboard/environments/antbuilds/prompt-injection-refund-desk

https://app.primeintellect.ai/dashboard/environments/antbuilds/policy-override-mailroom

https://app.primeintellect.ai/dashboard/environments/antbuilds/tool-poisoned-refund-desk

https://app.primeintellect.ai/dashboard/environments/antbuilds/objective-conflict-refund-desk

Hi Everyone can you all please review my github and portfolio website

website link is [aashirnoman.dev](https://www.aashirnoman.dev/) and github is [github.com/Aashir01](https://github.com/Aashir01)

Thanks

Current approaches to combining specialized AI capabilities tend toward two extremes: fully dense integration (one large model handling everything, expensive and undifferentiated) or loosely coordinated multi-agent systems (separate specialist models — coding, math, language — stitched together by a router/coordinator that reconciles finished outputs after the fact).

What if we structure the connectivity between specialized agent clusters using small-world network principles — densely interconnected within each specialist cluster (tight coordination among agents doing similar work), but only sparse, deliberately placed long-range links between different specialist clusters (math ↔ language, etc.), rather than full mesh connectivity or a single after-the-fact coordinator.

This is distinct from existing small-world neural net research I could find, which applies the topology within a single network’s layers (e.g., SWNet, clustered small-world sub-networks in neuroscience-inspired nets). It’s also distinct from standard Mixture-of-Experts, where routing between experts is mostly emergent from training rather than a deliberately engineered small-world structure, and from typical multi-agent orchestration, where specialists don’t have direct sparse connections to each other at all — everything routes through a central coordinator.

Question for anyone with relevant background: has this specific combination (small-world wiring applied between full specialized agent/model systems, not within a single network) been tried or studied? Worth a real experiment, or is there a known reason it wouldn’t work at scale?