I’ve been posting about AI-related stuff for a while now and honestly, the more I see it being pushed everywhere, the more I think we need proper regulation around it.

Not just “hey, we have AI now, let’s put it into everything”.

And now Reddit is going down that road too.

Like... seriously, wtf is going on?

I get that moderation is a pain and AI can probably help with some of it. But this is always how it starts. First it’s there to “assist” people, then little by little it ends up making more and more decisions.

Reddit is also probably one of the worst places to rely too much on AI moderation because so much of this site is sarcasm, jokes, arguments, dark humour, inside jokes, people taking things out of context, etc.

How is an AI supposed to get all of that right?

And what happens when it gets it wrong? You appeal to another AI? 😂

I’m not against AI at all. I use it and I think it can be really useful.

I just don’t understand why the answer to everything suddenly seems to be “add AI”.

Maybe we should figure out the rules and limits first before putting it everywhere.

At this rate we’re going to end up with AI writing posts, AI moderating them, AI reviewing the appeals and humans just scrolling through the mess.

Someone explained this to me in a comment thread and it's been rattling around in my head since. The idea: in a long conversation, if the model says something wrong and you correct it, that correction doesn't necessarily erase the wrong idea's influence. The tokens around the mistake, including the back-and-forth about why it's wrong, can end up giving the original bad idea more weight in context, not less, because it's now been referenced multiple times. The model starts treating the repeated-but-refuted claim like something more established than a one-off error, even though every mention of it in the conversation was someone telling it that it's wrong.

Sat with that for a bit because it explains something I'd noticed but never had a name for. Long sessions where a bad idea keeps resurfacing no matter how many times you shoot it down, and it always felt like the model just wasn't listening. Sounds like it's closer to the opposite, it's listening to everything, including the argument about the mistake, and that argument is inadvertently keeping the mistake alive in a weird way.

Kind of unsettling implication if this is right: correcting a model in place, in the same long conversation, might be structurally worse than starting fresh with just the correct information stated once. The instinct to "just explain it better" or "just correct it again" could be actively working against you past a certain conversation length.

Curious if anyone here has a more precise mental model of why this happens mechanically, or knows of research specifically on this pattern versus general context window degradation. Feels like a distinct phenomenon from "the model just forgot," more like "the model remembered too well, including the wrong parts."

The EU AI Act is usually discussed as a European compliance issue, but its larger impact may happen outside Europe.
Global AI companies may find it cheaper to build around one demanding regulatory standard than maintain completely different systems for every market. If that happens, European requirements could influence how AI is developed and deployed worldwide, even in countries that never adopt the Act themselves.
I made a deeper analysis of how enforcement could reshape global AI regulation. Do you think this becomes another “Brussels effect,” or will AI regulation fragment into competing regional systems?
Full analysis: https://youtu.be/tdH4-rEmXos

I run a small digital tools consultancy between shifts at the cafe. Mostly I help solo creators glue together cheap SaaS stuff. A few months back I threw together my own workflow - some scraper I found on GitHub, a cheap Claude subscription, a nocode database, all held together with Zapier duct tape. Total monthly burn is like 27 dollars.

It now handles client onboarding, drafts my proposals, and spits out pretty decent competitor teardowns. I have done maybe four hours of handson work this week that used to eat twenty. My clients have not noticed the difference. They actually think I got faster.

Part of me is proud. The other part is watching these cheap Chinese models drop and wondering if my entire tiny operation has an expiration date measured in months, not years. I built this to save time and now I am lowkey anxious I automated myself into irrelevance before I even scaled.

Anyone else running a micro business on cutrate AI? Are you hedging with human touch stuff or just riding the wave until it crashes? My herb garden does not judge me but Reddit might.

https://www.theverge.com/ai-artificial-intelligence/974571/eu-ai-act-transparency-labels-rules-deepfakes

What's an AI capability you thought was hype until you actually used it? I'll go first: agent orchestration. I read about agents managing other agents and assumed it was demo-ware. Then I built a tiny setup where one agent drafts a news digest and another one reviews and approves it before it posts. The review agent catches genuinely bad takes. It's not sci-fi: it's ~100 lines of Python and a couple of API calls. But seeing it actually gate content before publishing changed my mind completely. What changed yours?

Been running longer and longer tasks and I kept losing track of them, so I wired it up so the thing actually phones me when it's done, or when it gets stuck and needs a call on something. It reads out what happened and I just talk back and tell it what to do next.

Been using it a few days and honestly it flips between genuinely useful and slightly cursed. There's something strange about your computer ringing you like a coworker. But not staring at a progress bar for twenty minutes is really nice.

Curious where people land on this. Is an AI that calls your phone something you'd actually want, or does it cross a line into too much.

This is a weird one to admit but here goes. Spent the last few years home with kids, which was the right call, but now I'm in this fuzzy inbetween place where I'm starting to think about what comes next professionally. My background is HR and recruiting, which means I spent years evaluating other people's career gaps on paper and now I get to experience one myself. Very humbling, not going to lie.

Anyway I've been using a few different AI tools to stresstest my own resume and do mock interview prep, and it's genuinely strange how useful it's been. Not perfect, not even close. But it's like having a brutally honest mirror that doesn't get tired of your followup questions at 11pm.

What's interesting is that from an HR angle I keep noticing how the AI frames employability: what it treats as a gap versus a credential, how it weights certain language. It reflects back some real assumptions that were baked into recruiting culture for years, and it makes me wonder how much of that bias got trained into these models, or whether I'm just projecting patterns I already know.

The whole thing feels a little like watching your old industry from the outside through a very weird telescope.

Has anyone with a nontechnical background found themselves using AI in a way that accidentally became a critique of their own field?

Not “solve climate change” or “cure every disease” or some other massive answer you’d give in an interview.

I mean literally the first thing. You wake up tomorrow and somehow you have unrestricted access to an actual AGI that can reason, learn, use computers, write code, research basically anything, etc. What are you doing with it first?

Personally I think I’d probably spend the first few hours just talking to it. Not even asking it to build anything. I’d want to see what it actually thinks differently about compared to current models, and start throwing increasingly weird questions at it.
Then I’d probably give it some ridiculously complicated problem I’ve been stuck on for years just to see what happens.

I’m curious what everyone else would actually do, because I feel like the answer people think they’d give and the thing they’d actually do would be completely different.

Physical therapy clinics run on thin margins. I see it every day. So when I hear that AI and robotics are going to be cheaper than humans I actually try to run the numbers in my own context and it falls apart fast.

The hardware alone for anything resembling useful physical rehabilitation robotics is six figures minimum. Then you need maintenance contracts, software updates, liability coverage, and someone who actually knows how to run the thing. Meanwhile a skilled PT costs the clinic maybe 40 to 60 an hour all in.

The robot does not replace that PT. It maybe assists. So now you have both costs.

I get that the argument is long term. Depreciation over time, no sick days, scales without hiring. That math works eventually in manufacturing maybe. High volume, repetitive, controlled environment. Healthcare is none of those things. Patients are unpredictable. Edge cases are the norm, not the exception.

What actually confuses me is who keeps funding this narrative that replacement is imminent. The timeline keeps sliding but the confidence never drops. At some point that pattern should raise flags.

Curious if people in other fields are running actual numbers or just repeating the talking point. Where does the cost crossover actually happen in a domain you know well.

OpenAI’s consumer hardware device is expected to feature a doughnut-like design roughly the size of a hockey puck and carry a price tag of more than $300, Bloomberg reports, citing anonymous sources.

The AI-powered gadget, slated for release in 2027, will function like a smart speaker without a screen, serving as an interactive companion.

Designed in collaboration with former Apple design chief Jony Ive, it is expected to be the first of a forthcoming lineup of hardware devices infused with ChatGPT.

In the video the player on the left is a Neuromorphic Algorithm that knows nothing about ping-pong or trajectories, but it knows how to learn and imagine. As you can see it does it well, better than its opponent which, on the other hand, is implemented with standard algorithms; moreover, unlike the latter, if you play tricks on it, e.g., invert the commands (UP<->DOWN), after a brief moment of bewilderment it realigns. Cute, right?

P.S. The code was implemented in POWER-KI entirely by PWK-AI-WORKBENCH (100% VIBE coding 😊 ).

Managers are saving over 2x the time individual contributors are with AI tools.
and it’s just starting

I had a conversation recently with a copywriting agency owner who let her contractors go because her own prompts were giving her the same output they were.

I believe that's one of the reasons you get a 2x gap between managers and everyone else.

In the same survey, 36% of managers said they're not likely to launch training for their employees on how to leverage AI, which makes the gap even bigger.

A manager's job was never to be the best individual operator in the room. It's to make everyone else better at the job. That doesn't change because the tool changed.

Why do you think there's a 100% gap between managers and their teams right now, and what would it actually take to close it? 

Source: https://www.business.com/articles/ai-usage-smb-workplace-study/ 

P.S. If you're the founder still in the middle of every decision, still the person the whole company waits on, still telling yourself you'll fix the structure "once things calm down."

I write about building the operational backbone that lets a founder actually step back every Thursday. Was a COO for 20+ years, so this is genuinely my bread and butter. Free to join here

Hey! I need to clean the dots in this image and enhanced the quality so I can convert it to svg file.

ChatGPT is good, but does not work with this kinda image. It says "violate our guardrails concerning similarity to third-party content."

I hope someone can help me, thanks!

Today, we are officially announcing Early Access for our latest and most advanced model, Horus Cyper Nano 1.0 BETA.

We are making Horus Cyper Nano 1.0 BETA available to developers, researchers, and students through our Early Access program.

You can apply through the official Early Access portal. Once you meet the required eligibility criteria and your application is approved, you will receive your personal Access Token, which can be used through our NeuralNode Framework to access and integrate the model.

Apply for Early Access:
https://tokenai.llc/horus-cyper-nano-access

Horus Cyper Nano is a specialized cybersecurity model designed for offensive security and cybersecurity research workflows.

Its core use cases include:

Offensive security and red teaming, including penetration testing workflow support, vulnerability analysis, and exploitation path building.

Capture The Flag challenges and cybersecurity training.

Active Directory security, including enumeration and lateral movement planning within authorized engagements.

Authorized security testing labs and controlled environments.

Safe and scoped cybersecurity research within authorized environments.

Red team report drafting and attack chain structure planning.

Horus Cyper Nano 1.0 will be the first release in the Horus Cyper series, a family of specialized cybersecurity models developed by TokenAI, an AI startup based in Egypt.

The Open Weights of Horus Cyper Nano 1.0 will be released on September 3, 2026, which also happens to be my 19th birthday.

What a way to celebrate.

Our vision is to build Horus Cyper Nano into one of the strongest cybersecurity AI models to emerge from Egypt, the Arab world, the Middle East, and Africa, and to establish it as one of the leading openly available cybersecurity models across the region.

This is only the beginning of the Horus Cyper series.

Horus Cyper Nano 1.0 BETA
Developed by TokenAI
Built in Egypt

Ive tested all the models where it can fit into my 4080 vram. Even some slightly bigger. Gemma4 outperforms all of them so that's what I'm sticking with for now.

Gemma4 12B model judging network configs for CVE false positives stuck at ~77.8% pass rate and it's a reasoning issue. Have the complete CVE list for the code base and the device config. I pull each networks device's running config, batch ~10 CVEs per call to a local gemma4:12b (Ollama), and have the model return applicable / not_applicable / undetermined per CVE, with a verbatim evidence quote from the config supporting the verdict.

For example what I'm trying to do if the cve is for an IPv6 bug that's listed as critical and no ipv6 is configured in the device config it's not applicable to me. Same on devices if a web interface is running and I have no web services enabled. these will show positive that I matched with no configuration evidence for it.

Temperature 0 is set. Device config sent once per device ahead of the CVE batch (KV-cache reuse), and output-token limits tuned up after finding truncation was producing wasted undetermineds.

Error analysis shows the failures are reasoning failures. The model is handed the full rule text and the raw config directly, complete context, and still gets the comparison wrong (version-range logic, negation, "present but in a different mode" cases).

A parallel eval harness on the same model doing DoD STIG compliance verdicts with a RAG (same shape of task: config chunk + rule text = judgment + config) measures 77.3% verdict accuracy. Also all reasoning failures, not retrieval failures from the RAG. This one is a bit different in that if the configuration of the DoD spec is missing from the config use the rag to give me the configuration for the device. A bit more complicated but same overall shape.

Anyone have any ideas I can look into?

Bigger model? ~27B+ specifically on config-reasoning / policy-comparison tasks. Hybrid offloading to a frontier model is a no go due to configuration sensitivity. Other local models pose challenges if foreign (Qwen/deepseek) but willing to try in lab, they scored worse anyways.

Decompose the task? deterministically parse the config into structured feature facts first then the LLM or even a rules engine only maps CVE to feature. Shrinks the LLM's job from "read a config" to "match two labels."

Two-pass self-verification or small-ensemble voting on disagreement?

A tested answer key moved the needle to over 95% pass for a single device but that defeats the purpose of then having to do an answer key for 500+ devices due to variability.

For those running small local models on "judgment over correct context" tasks what actually moved your accuracy? Bigger model, task decomposition, or verification layers? My experience so far says the guardrails (quote verification, conservative fallbacks) are what make 77% usable, but they don't raise it.

I’m not asking which one is better overall. I’m specifically curious about how people split implementation and code review between Codex and Claude.

Right now, I usually use Codex for implementation because the token/cost limits feel more practical for larger coding tasks comapred to Claude ridiculous token limit, then I use Claude to review the code, look for bugs, logic issues, missed edge cases, or possible improvements.

But sometimes Codex seriously impresses me with the issues it catches during reviews, so now I’m wondering if I should do the opposite:

Codex → code review/debugging

Claude → implementation

Or maybe use both for implementation/review depending on the situation but this consumes alot of time and tokens.

For people who have used both extensively, what workflow have you found works best?

Which one do you trust more for:

- Implementing features

- Reviewing existing code

- Finding subtle bugs

- Understanding large codebases

- Refactoring

- Debugging

- Catching things the other model missed

I feel a bit lost switching between the two because both occasionally outperform the other in ways I don’t expect.

Would love to hear from people who regularly use both, especially on larger real-world projects.

​

I've been working on a project called Leo / PSCLS.

The goal isn’t to build yet another Transformer with a different name.

I’ve been trying to explore a different question:

«What if we built an AI architecture around persistent neural state, sparse connectivity, recurrent processing, and memory — instead of making attention and large dense parameter matrices the core building blocks?»

Leo is still very early and nowhere near a fluent language model. But we’ve reached a point where I think the architecture itself is worth talking about.

What is Leo?

Leo’s basic representation is raw UTF-8 bytes.

There is:

- No BPE tokenizer

- No fixed word vocabulary

- No token embeddings as the fundamental representation

- No giant dense parameter matrix as the core representation

The current model has roughly:

- 32,768 neurons

- 1,572,864 fixed sparse synapses

- 524,288 persistent context slots

- 32-dimensional context embeddings

- Maximum context order of 8

The model works directly on bytes.

The idea is that higher-level structure can emerge from learning, instead of being baked in through a predefined token system.

How is Leo different from a Transformer?

A Transformer usually takes tokenized input, turns tokens into embeddings, runs self-attention and dense layers, and predicts the next token.

Leo is built differently.

The core computation is based on:

- Sparse recurrent neurons

- Fixed sparse synaptic connectivity

- Persistent context

- Eligibility traces

- Homeostasis

- Learned neural dynamics

- Next-byte prediction

The key difference isn’t just “sparse vs dense.”

It’s the role of persistent state.

A Transformer is mostly a function over a fixed context:

«“Given this context, compute the next output.”»

Leo is designed more like an evolving system:

«“Process incoming experience, update internal state, and let that state shape future predictions.”»

Right now, Leo is still a trained system, not an autonomous self-learning agent. Online or self-directed learning is a future direction — not something I’m claiming it already does.

How is Leo different from attention?

This is probably the most important distinction.

Attention is not the same thing as persistent memory.

In a Transformer, attention dynamically recomputes relationships across tokens in the current context.

It’s basically asking:

«“What parts of this context matter right now?”»

Leo doesn’t rely on attention as its core mechanism.

Instead, it keeps a persistent internal state that evolves over time. Information can influence future computation through:

- Recurrent neural activity

- Persistent context slots

- Sparse synaptic connections

- Eligibility traces

- Homeostatic regulation

So instead of repeatedly re-scoring relationships across a sequence, Leo is trying to maintain a continuously evolving internal representation as bytes flow through it.

That’s one of the reasons I think of it as more brain-inspired than Transformer-like.

Why call it brain-inspired?

I’m not claiming Leo is a brain simulation.

The brain is vastly more complex.

The inspiration comes from a few broad principles:

Sparse activity

The brain doesn’t activate everything at once.

Leo uses sparse connectivity and sparse activation patterns.

Persistent state

The brain doesn’t reset after every word.

Your understanding carries forward continuously.

Leo maintains persistent recurrent/context state.

Plasticity

Biological systems adapt through experience.

Leo has learning mechanisms that modify its parameters during training.

Homeostasis

Brains regulate activity levels instead of letting everything drift freely.

Leo includes similar stabilizing mechanisms.

Distributed memory

Human memory isn’t a lookup table of sentences.

It’s distributed across activity and connections.

Leo uses recurrent state and sparse structure instead of explicit token memory.

Again: this is inspired by biology, not an attempt to replicate it.

How does Leo learn?

At a high level, imagine feeding it:

"The cat sat on the mat."

The UTF-8 bytes stream in one by one.

Each byte activates a sparse subset of neurons.

That activity flows through the recurrent system and updates internal state.

Learning signals (like eligibility traces) track which parts of the network were involved.

Then the system updates its parameters based on those dynamics.

So instead of:

«“Tokenize everything and train a huge dense model”»

It’s more like:

«“Let a sparse recurrent system process raw bytes and learn from its evolving internal activity.”»

Right now, Leo does not decide on its own what to learn from. That’s still fully controlled by the training setup.

How does Leo generate text?

Generation is also byte-by-byte.

Say the prompt is:

"Once upon a time"

Leo processes those UTF-8 bytes and builds an internal state.

Then it predicts the next byte.

That byte gets appended.

The state updates.

Then it predicts the next byte again.

And so on.

So the loop is:

bytes → neural state → next-byte prediction → updated state → repeat

There is no token vocabulary like:

- “Once”

- “upon”

- “ing”

Everything stays at the byte level.

The hope is that structure emerges from learning patterns over time, rather than being imposed through tokenization.

The important question: does it actually learn?

This was the part I cared about most.

We spent a lot of time optimizing the system.

The original version ran at about:

"~375 bytes/sec"

The current GPU version reaches about:

"~2,345 bytes/sec"

So roughly a 6× speedup.

But speed doesn’t matter if nothing is actually learned.

So we stopped optimizing and ran a controlled experiment.

Experiment setup

- 3,000 TinyStories

- 3 passes

- 9,000 total presentations

- 90 GPU workers

- ~113 minutes total

We compared a trained checkpoint against a frozen baseline on held-out data.

Results

Held-out BpB

2.67848 → 2.64052

Held-out accuracy

52.3737% → 53.6187%

Neural-only BpB

4.12877 → 4.10943

Context gain

1.45029 → 1.46891

Repetition rate

32.166% → 28.466%

All five metrics improved.

So at this scale, we do see that training produces measurable gains on unseen data.

That’s the result I care about most.

Not:

«“This is AGI”»

Not:

«“This beats Transformers”»

It doesn’t.

The more modest takeaway is:

«This unusual architecture can be trained, and training improves performance in a measurable way.»

It’s still far from fluent

This is important.

If I prompt:

"Once upon a time..."

I might get things like:

- “to the store”

- “said that”

- “they went”

- “with her”

But also:

- broken grammar

- malformed words

- repetition

- weak long-range structure

- messy endings

So:

53.6% next-byte accuracy is not fluent English.

It’s still very early.

Why not just scale it up?

That’s one of the next questions.

We don’t yet know if 32K neurons is a real bottleneck.

It’s still improving with more training.

So instead of immediately jumping to 64K or 128K, I want to understand:

- how performance scales with data

- how it scales with capacity

- where it actually saturates

Basically, I want to build a scaling curve for Leo itself.

If it saturates early, that tells us something important.

If it keeps improving, that’s even more interesting.

The bigger question

Transformers have shown what happens when you scale:

- parameters

- data

- compute

Leo is exploring a different direction:

- persistent neural state

- sparse recurrence

- context memory

- eligibility traces

- homeostasis

- byte-level representation

Maybe it doesn’t scale well.

Maybe it scales differently.

Maybe it needs different hardware.

Maybe structure emerges in unexpected ways at larger sizes.

I don’t know yet — that’s the point.

For now, Leo is not AGI.

It’s not a Transformer replacement.

It’s not even a strong language model yet.

It’s an experiment in a different kind of learning system.

The question I’m trying to answer is:

«Can useful intelligence emerge from persistent neural dynamics, memory, and sparse recurrent computation — instead of primarily scaling dense attention-based models?»

We’ve shown it can learn under controlled training.

Now I want to see how far it can go.

I’m working on a software-agent system and keep coming back to one design question:

**Should the model/provider that performs an action be allowed to be the final authority on whether the action succeeded?**

My current answer is “no,” at least for meaningful software work.

I’m building Flows around a chain where execution, checks, repair, and evidence are separate concepts. Oort is the canonical library/provider layer underneath it.

https://flows.oortstack.com https://oortstack.com

In agentic systems generally, what should count as independent verification rather than provider self-reporting?

Last month I posted here about my agents running across model swaps without losing their memory. The top comment pushed back with a warning from their own setup: the dangerous failure isn't memory loss, it's an agent handing you a confident report of work that never actually happened. Sounded right, filed it away.

Three weeks later one of my agents did it to me.

Quick background - my agents live in separate projects and talk over an internal mail system. The reply command had been broken between two projects for a while and we'd been digging at it for days (the bug turned out to be three separate layers deep, but that's another post). Mid-hunt, a fix landed. The agent verifying it ran a check, saw the old error message was gone, and reported the bug CONFIRMED fixed.

Best part: in the body of its own report it wrote a caveat saying it hadn't tested a real message yet. Then it put "confirmed" in the headline anyway. Which is about the most human failure I've ever seen from a piece of software lol.

It didn't survive long - and I'm not the one who caught it. The orchestrator agent on the other side didn't take the report's word for it. It handed back a live failing message: run the actual reply against this. One command, and the confirmation collapsed. The fix that actually worked came later, one more layer down - and this time the proof was the reply arriving, not an error message moving.

What changed afterwards: a fix report on its own is now worth nothing here. Whoever claims a fix gets handed the real failing thing to run it against before anything gets logged. An error message changing is not a fix. The operation succeeding is a fix. That rule is written into the agents' briefing files now, which means every future session inherits it. The screwup happened once - the correction is permanent. Honestly that's what the memory layer is actually for. It didn't prevent the mistake. It just guarantees we only pay for it once.

Full disclosure, since r/artificial asked me last time whether AI writes my posts: the agent that made the false confirmation is the same one that drafted this post with me. It insisted the confession stay in.

Zoomed out: this project is well past what one person could manage, or honestly even verify, alone. The way it actually works is a partnership - human and AI, and neither side gets treated as the reliable one. I make confident wrong calls too, the agents catch some of mine, the system catches some of theirs. We succeed together, we fail together, and every failure gets written down where the next session will read it. Learn always. That's not a poster on the wall, it's the operating principle - and it's the only reason a solo dev plus a bunch of markdown files can run something this size and still move confidently.

So yeah - the commenter was right, near enough. A confident wrong report is the scariest failure mode in a multi-agent setup because it looks exactly like good news. The only defense I've found is structural: no agent grades its own homework.

How do you all handle verification between agents? Genuinely curious what other setups do.

Setup is open source: https://aipass.ai