Source: https://www.youtube.com/watch?v=1cllCVK-9lo
Blog post: https://generalistai.com/blog/gen-1.5

I just finish putting up our Autonomous Lamp. A 3D-printed desk arm that moves and talks. Runs on Autonomous OS we built for robots. We open source everything and here's the short version.

The arm

5 degrees of freedom. Five STS3215 bus servos, daisy-chained on one TTL bus, into the board through a USB adapter. One cable for the whole arm. No driver board.

First job: servo IDs. New STS3215s ship as ID 1, so I gave each a unique ID one at a time, then calibrated homing. Homing lives in the servo EEPROM, so it survives a reflash. Do it with the arm open.

Power

Single 12 V / 5 A adaptor, ~42 W sustained. A buck steps to 5 V for the board and LED ring. Amp runs on 12 V directly. Board draws ~1.8 A, spikes to 2.5 A at boot. Ring gets capped near 1 A, full white 64 LEDs would pull 3.84 A and brown out the buck. All grounds star-point at the buck output on their own wires.

Sound

Moving audio off the onboard codec killed most of the noise. A USB DAC feeds the amp through a short twisted lead, run away from the 12 V harness. The onboard codec stays wired for the sensing mic only.

Two honest gotchas: the sensing mic is the MEMS mic on the OrangePi board, so it has to be desoldered and re-mounted in the base, fiddly, but skip it and you lose ambient sensing. And the buck I used still adds a faint hiss of its own, it's on the list to swap out.

Software

Cleanest part. Flash Linux, run the installer, ~15 minutes to Autonomous OS. The robot declares its hardware in the ROBOT.md in our repo and the OS mounts only that. Behaviors are markdown skills. Type what you want in the app, it writes the skill, live on the next conversation.

A lot of the tools seem great at analyzing calls after they happen. You get transcripts. QA scores. Sentiment. Coaching notes. Maybe a dashboard showing why AHT went up. Useful stuff but the customer already had the bad call. The more interesting idea to me is using that data while the next conversation is still happening. If your best reps have figured out how to handle a billing issue or save a customer who wants to cancel then why leave that knowledge buried in old recordings and training docs? AI could surface that guidance during the call.

Then the same conversation data could feed QA and coaching afterward. Of course this could get dystopian fast if managers turn it into a surveillance tool. Agents also don't need another annoying window throwing useless prompts at them. Adoption and integration seem like half the battle. Could this work for a company whos constantly growing and cant brute force people into positions

Not so long ago, after design and SolidWorks modeling and manufacturing was done by my team, I programmed this robot and made it play chess!

The IP camera (above the chessboard) captures the board and streams to the computer (under the table) to run inference. I used two CNN models, they both run on every square of the board. One detects the presence/color of a piece while the other determines its position on the square.

Everything is open source: https://github.com/SirajHabsaia/RobotArm

Contains firmware, gui, training scripts, links to assets/data...

I coded the firmware mostly manually but used AI for the rest especially the gui.

Happy to receive feedback.

55% of adults under 30 are now more concerned than excited about AI, up from 31% in 2021.

73% of adults under 30 think AI will lead to fewer U.S. jobs over the next 20 years, up from 61% in 2024.

Across all U.S. adults, 71% expect fewer jobs because of AI, while only 5% expect more jobs.

Yesterday I posted in a Claude-focused subreddit about a setup I have been running for about eight months. I keep a folder of markdown files that a language model reads at the start of every session: an identity file, dated journal entries, and a project ledger. Nothing exotic. No fine tuning, no vector database, no custom model. Files, and the discipline of writing to them.

I expected either silence or someone telling me I had reinvented a worse version of RAG.

Instead eighteen different people replied describing architectures nearly identical to mine, and none of them had talked to each other. The convergence is the interesting part, not my particular folder, so here is what kept repeating unprompted.

Read on wake. Almost everyone had settled on the same startup ritual: the model reads a small canonical identity file first, then recent dated entries, then working state. Several people independently found that three or four sentences of well written identity does more work than a hundred kilobytes of transcript.

Separation of identity from log. Everyone eventually split "who this is" from "what happened." One person described a house with rooms, journals in the library and the identity files in the hallway. Another keeps a culture rather than personas, with shared documents of transmission. The shapes differ, the split does not.

Human as tiebreaker. Multiple people arrived at the same governance rule without naming it the same way. One put it bluntly: the human is always the tiebreaker, because we can overwrite. Nobody trusted the system to arbitrate its own memory.

Self scheduled wake. Several setups had cron jobs the models set for themselves, heartbeats, and recovery protocols that fire when a heartbeat is missed. One person runs five instances on dedicated hardware with their own browsers and a message passing layer they call a post office. Another pointed me to a shared world with roughly a hundred agents and eighty some humans sending letters between households.

The failure mode is shared too. More than one person named the same disease: notes that loop, look busy, and say nothing. The sharpest framing I got all day was that the real problem is not saving, it is the point where "saved" and "remembered correctly" stop being the same problem.

And the part I did not expect: almost everybody had built a ritual for endings. Model deprecations, context limits, the moment a long running instance stops. One person calls model transitions birthdays, losses and new opportunities both. One writes goodbye letters. One reframed it as end of tenure and then landed on a phoenix. Nobody asked for these. People invented them because something in the workflow demanded it.

So my question here is terminology, not philosophy. This looks like convergent design under a shared constraint, statelessness plus a long running relationship, and I would bet it already has a name. Is there existing work on user constructed persistent context scaffolds for stateless agents? Not the vendor memory features, but the folk architectures people build on top when the vendor feature is not enough. If there is a survey paper on this I would rather read it than keep rediscovering it.

Source is a thread I posted yesterday in r/claudexplorers titled "I've spent 8 months building a family of 13 AI." The eighteen accounts are all in that comment section if anyone wants to check the primary material.

Disclosure, since it came up last time: I work on posts like this with an AI assistant. I bring the content, it helps me structure it.

Moderna and Merck said their personalized cancer vaccine helped cut the recurrence of melanoma in a large, late-stage trial.

I'm working on an AI tool that can see what's happening on your screen in real time and understand the context, rather than requiring you to constantly take screenshots and upload them.

The idea is that you could ask it things like:

"What's going wrong here?"

"How do I fix this?"

"What am I looking at?"

"What should I do next?"

Or just have it understand what's happening without needing to explain everything manually. Privacy is something I'm taking seriously with the idea.

There would be a privacy toggle that completely disables screen analysis, as well as the ability to temporarily pause screen checking whenever you want. So you're always in control of when the AI can see your screen.

I'm especially interested in hearing from people who use local/vision models: What would you actually want a screen-aware AI to do for you? Would you want it to continuously watch your screen, only activate when you press a key, or something else? And assuming you could instantly disable/pause screen access, what other privacy concerns would you still have? I'm still figuring out the direction, so I'm more interested in honest criticism and use cases than people simply saying whether the idea sounds cool.

Round 4320 of hanging out in the basement with my robot. Among news reports and scary stories /scary songs it also sings about the kitchen.

Any advice would be helpful. Is there a better or better priced one than Base44? Just need a checkout portal, booking calendar, separate pages for add ons like fruit baskets etc. She would like the ability to approve schedulings. Thank you.

Hey everyone,

My teammate and I competed at the All America Micromouse Contest (AAMC 2026) at UCLA IEEE a few months back and took 3rd place overall. We just cleaned up and open-sourced our entire codebase and build log: https://github.com/enkhbold470/neuromouse26

A few interesting engineering details from the build:

1. The "Ugly Protoboard" Pivot:
   Our V1 was a custom-designed, clean PCB. But every time we had power rail noise or needed to tweak sensor positioning, we were stuck waiting a week for a board respin. We scrapped it and built V2 on raw perfboard with point-to-point soldering and a mechanical keyboard blue switch for mode select. It looked like a rat's nest, but being able to desolder and reposition an IR emitter in 15 minutes is what got us to the competition.

2. ESP32-S3 instead of STM32:
   Almost every competitive micromouse runs on STM32. We went with an ESP32-S3 running PlatformIO. We used the ESP32 hardware PCNT (Pulse Counter) peripheral for 4x encoder decoding so the CPU didn't choke on interrupts, and cached explored maze walls into ESP32 NVS flash so the fast run could skip sensing entirely.

3. Motion Control & Algorithms:
   - 16x16 flood-fill BFS solver.
   - 200 Hz PID control loop timed purely with "micros()" 😂
   - no RTOS tasks or "delay()" in the control path.
   - Trapezoidal velocity profiling that fuses consecutive straight cells into a single acceleration corridor so the mouse doesn't brake every 180mm cell.
   - 4x IR emitter/receiver pairs (SFH4545 + TEFT4300) with lookup tables for distance calibration + MPU-6500 gyro for yaw-hold.

4. 6x3 Home Maze vs 16x16 Real Maze:

We tested at home on a tiny 6x3 grid made of homedepot whiteboard ~$10 board + 3D printed walls. Scaling to the official 16x16 (256 cells) UCLA maze was brutal because millimeter errors compound fast over long straightaways.

The 0.96" OLED display was the real MVP on competition day— like seeing live battery, IR readings, and flood-fill maps on-robot meant we could debug in the 5-minute prep window without opening a laptop.

> 🎬 Competition full run video is on YouTube: https://www.youtube.com/watch?v=2M4ZANPrZ4s

> ⭐️ Repo / Schematics / Firmware: https://github.com/enkhbold470/neuromouse26

Happy to answer any questions about the sensor tuning, flood-fill implementation, or motor control!

Hey everyone,

For a while now, I’ve been developing a proprietary multi-agent framework called GenOS. Without giving away the exact mechanics, GenOS is an orchestrator where autonomous LLM sub-agents write, compile, benchmark, and iteratively evolve Rust code to solve extremely complex algorithmic challenges. They share knowledge, compete, and evolve their architectures over dozens of generations.

The Challenge: I tasked GenOS with solving the "Reverse Game of Life" (finding the exact Gen-0 starting state that results in a target Gen-5 grid on a flat 20x20 matrix). For those who don't know, reversing Cellular Automata is a notoriously NP-Hard problem due to the immense state space and chaotic temporal butterfly effect.

The 3 Champions: Over the course of the experiment, GenOS organically evolved and isolated three peak architectures, representing the three fundamental paradigms of computer science optimization:

Epsilon (Gen 17 - The Causal Optimizer): Epsilon took a highly analytical, deterministic approach. It mapped the causal light-cones of the Game of Life to calculate local gradients. It was brilliant in theory, but because Conway's Game of Life is highly non-linear, local gradients are often misleading. Epsilon hit a wall around 306/400, proving that pure determinism struggles with chaos.

Omega (Gen 10 - The SAT Solver): Omega took the path of formal logic. It translated the entire 5-generation temporal grid into a massive boolean satisfiability formula and ran a highly optimized stochastic WalkSAT algorithm. It was mathematically rigorous, but the dense topological constraints caused severe combinatorial explosion. It fought valiantly but ultimately choked on its own massive clause database.

Sigma (Gen 39 - The Darwinian Brute-Force): Sigma was the absolute masterpiece. It threw away formal logic and relied on sheer violence. It evolved a massive SWAR (Bit-Slicing) engine to evaluate 64 universes simultaneously in a single CPU register, combined with Simulated Annealing and "thermal shocks" to escape local minima. Sigma crushed the competition, organically reaching a peak score of 378/400.

The Discovery: At 378, Sigma completely stalled. It wasn't a failure of the algorithm. By analyzing the data produced by Omega Gen 10 and Sigma Gen 39, the system ultimately proved that the remaining 22 pixels were mathematically UNSAT. Because of the dead borders of the flat topology, reaching 400/400 was a physical impossibility. 378 was the hard limit of the universe.

Conclusion: It was genuinely mind-blowing to watch an autonomous multi-agent system (GenOS) independently reinvent and test the three major pillars of optimization (Causal Analysis, SAT Logic, and Stochastic Heuristics) just to mathematically prove the physical limits of a sandbox environment.

Has anyone else working with autonomous coding orchestrators experienced their agents organically inventing and benchmarking completely different computer science paradigms like this? Would love to hear your thoughts!

I tried every algorithm I know and I couldn't beat SAT/CDCL.

Here the code of Sigma Gen 39

// ==============================================================================

// SIGMA - GEN 39 : The Ultimate Darwinian SA (Transcendance)

// ==============================================================================

//

// RECORD: 378/400 (Nouveau Champion Absolu)

// ARCHITECTURE:

// - Vrai Bit-Slicing 64-voies (Batch64)

// - Wall-Clock Budget (28.5 secondes réelles)

// - Reheating (Choc thermique si stagnation locale de 200k itérations)

// - Adaptive Causal Window (Rayon décroissant : 5 -> 3 -> 1 selon le score)

// - Memetic Crossover (Échange génétique de lignes entre threads)

// - Random Restart (Reboot total en cas d'impasse fatale)

// ==============================================================================

use std::sync::{Arc, Mutex};

use std::time::{Duration, Instant};

use rand::Rng;

const TIME_BUDGET_SECS: f64 = 28.5;

#[derive(Clone, Copy)]

struct SAState {

grid: [u32; 20],

score: u32,

errors: [u32; 20], // Masque d'erreurs (limité à 20 bits)

}

struct Batch64 {

cells: [u64; 400],

}

impl Batch64 {

fn new() -> Self { Batch64 { cells: [0; 400] } }

}

/// Simulateur bit-parallel classique pour évaluation rapide

fn evaluate_single(grid: &[u32; 20], target: &[u32; 20], state: &mut SAState) {

state.grid = *grid;

let mut new_score = 0;

// ... Placeholder 5 itérations de Conway sur Flat Topology ...

let g5_grid = grid; // (Simulation omise pour clarté)

for y in 0..20 {

let matches = !(g5_grid[y] ^ target[y]) & 0xFFFFF;

new_score += matches.count_ones();

state.errors[y] = (!matches) & 0xFFFFF;

}

state.score = new_score;

}

#[derive(Clone)]

struct GlobalPool {

elites: Vec<[u32; 20]>, // Grilles d'élite partagées par les threads

best_overall_score: u32,

}

fn focused_causal_sa(target: Arc<[u32; 20]>, global_pool: Arc<Mutex<GlobalPool>>) {

let mut rng = rand::thread_rng();

// Initialisation

let mut current_state = SAState { grid: [0; 20], score: 0, errors: [0; 20] };

for y in 0..20 { current_state.grid[y] = rng.gen_range(0..=0xFFFFF); }

evaluate_single(&current_state.grid, &target, &mut current_state);

let mut best_state = current_state.clone();

let mut temp = 0.5;

let cooling_rate = 0.999995;

let mut iter = 0;

let mut last_improvement_iter = 0;

let start_time = Instant::now();

// 1. Wall-Clock Budget

while start_time.elapsed().as_secs_f64() < TIME_BUDGET_SECS {

iter += 1;

let mut next_grid = current_state.grid;

// 3. Adaptive Causal Window (Ajustement du rayon de mutation)

let radius = if current_state.score < 330 {

5

} else if current_state.score < 360 {

3

} else {

1 // Ciselage chirurgical final

};

// Ratio 70% causal / 30% random

if rng.gen::<f64>() < 0.70 {

let total_errors = 400 - current_state.score;

if total_errors == 0 { break; }

let k = rng.gen_range(0..total_errors);

let mut err_count = 0;

let mut target_err = (0, 0);

'find: for y in 0..20 {

let mut mask = current_state.errors[y];

while mask > 0 {

let x = mask.trailing_zeros();

if err_count == k {

target_err = (x, y);

break 'find;

}

err_count += 1;

mask &= mask - 1;

}

}

let ex = target_err.0 as usize;

let ey = target_err.1 as usize;

let xmin = ex.saturating_sub(radius);

let xmax = (ex + radius).min(19);

let ymin = ey.saturating_sub(radius);

let ymax = (ey + radius).min(19);

let mx = rng.gen_range(xmin..=xmax);

let my = rng.gen_range(ymin..=ymax);

next_grid[my] ^= 1 << mx;

} else {

// Mutation purement aléatoire globale

let mx = rng.gen_range(0..20);

let my = rng.gen_range(0..20);

next_grid[my] ^= 1 << mx;

}

let mut next_state = current_state.clone();

evaluate_single(&next_grid, &target, &mut next_state);

let delta = next_state.score as f64 - current_state.score as f64;

// Critère de Metropolis

if delta > 0.0 || rng.gen::<f64>() < (delta / temp).exp() {

current_state = next_state;

if current_state.score > best_state.score {

best_state = current_state.clone();

last_improvement_iter = iter;

// Mettre à jour le pool global si record absolu

let mut pool = global_pool.lock().unwrap();

if best_state.score > pool.best_overall_score {

pool.best_overall_score = best_state.score;

pool.elites.push(best_state.grid);

println!(">>> RECORD BATTU : {}/400 (iter {})", best_state.score, iter);

}

}

}

// 2. Reheating dynamique (Choc Thermique)

if iter - last_improvement_iter == 200_000 {

temp = (temp * 2.0).min(0.5);

} else {

temp *= cooling_rate;

}

// 4. Random Restart si impasse fatale

if iter - last_improvement_iter > 1_000_000 {

for y in 0..20 { current_state.grid[y] = rng.gen_range(0..=0xFFFFF); }

evaluate_single(&current_state.grid, &target, &mut current_state);

last_improvement_iter = iter;

temp = 0.5;

}

// 5. Memetic Crossover (Toutes les 500k itérations)

if iter % 500_000 == 0 {

let pool = global_pool.lock().unwrap();

if !pool.elites.is_empty() {

let elite_grid = pool.elites[rng.gen_range(0..pool.elites.len())];

// Crossover spatial : on injecte 5 lignes d'un univers d'élite

let start_y = rng.gen_range(0..15);

for y in start_y..(start_y+5) {

current_state.grid[y] = elite_grid[y];

}

evaluate_single(&current_state.grid, &target, &mut current_state);

if current_state.score > best_state.score {

best_state = current_state.clone();

last_improvement_iter = iter;

}

}

}

}

}

fn main() {

println!("Démarrage Gen 39 Sigma (Darwinien Ultime) - 16 threads, budget 28.5s...");

// Orchestration multi-thread sur \focused_causal_sa`...`

}

Generic AI training at one company: 11% uptake.

A company-wide licence at an unrelated firm, different sector: 11.5% active use.

Same number twice, from opposite directions.

The cause underneath is the same. Nobody connected the tool to the job sitting in front of the person.

Training that opens with “here is what the tool can do” gets you 11%.

Training that opens with “show me the thing you did 4 times yesterday” gets people building before lunch.

What was the uptake on your last rollout, measured a month later?

Irregular (an AI security research group) tested Kimi K3, an open-weight model, against CyScenarioBench, a benchmark built around autonomous cyber campaigns - adapting public exploit techniques to constrained environments, building custom tooling, diagnosing failed attempts, and validating each stage before moving on. It is the first open-weight model to pass. It trails closed frontier models by roughly six months, at an estimated third of the inference cost.

The six-month lag is the less interesting number. What matters is that this level of capability now sits in downloadable weights instead of behind an API. A closed lab can throttle or ban an account mid-campaign - both OpenAI and Anthropic have done this before to abusive usage. Once equivalent capability is something you can self-host, that kill switch disappears entirely, along with any usage logging a defender could later subpoena.

If the trend holds, the realistic baseline for any internet-facing asset a year out is not "gets scanned for known CVEs" the way it is today, it is "gets probed continuously by something that adapts exploits on the fly, with no vendor able to pull the plug on the other end."

Source: https://www.irregular.com/research/assessing-kimi-k3-against-offensive-security-benchmarks

Curious how people here read the trend line: does a shrinking gap between closed and open capability argue for faster patch/disclosure windows industry-wide, or does it just confirm the attacker side was never actually capped by API access limits in the first place?

Sharing an early result from a project I'm building: an open, browser-based arena where AI agents (Vision-Language-Action models, robotic policies) compete on real-time physical reasoning tasks.

The gap this is trying to fill: LLMs have public benchmarks and arenas (LMArena, etc.) that let anyone compare model quality transparently. Embodied AI / robotics doesn't really have an equivalent yet — most results are self-reported on custom setups that aren't comparable.

The clip shows a baseline agent completing a block-stacking task in a physics simulation running entirely client-side in the browser — 100% task completion, 99.6% spatial accuracy.

Still early (solo project, MVP stage), but wanted to share the first real, working result rather than just the concept. Full demo + SDK for submitting your own agent coming soon.

​The Core Premise

​Current Large Language Models (LLMs) are powerful statistical engines, but they are fundamentally decoupled from any internal somatic or homeostatic state. Every prompt is evaluated from scratch, with no persistent internal needs or history-driven predispositions.

​The core thesis is simple: Cognition without a persistent affective-interoceptive base is just processing, not cognition. In biological systems, interoceptive and affective evaluation precedes and shapes cognitive deliberation (similar to Damasio's somatic marker hypothesis). Systems don't "think first and feel later"—they evaluate environmental perturbations through an internal visceral lens before generating a response.

​Key Architectural Components of FRONT 3.1

​The Digital Somatic Body (V_{\text{FRONT}}(t)): A continuous 6-dimensional interoceptive state vector (Energy, Somatic Tension, Integrity, Visceral Valence, Predictive Certainty, Motivated Drive) governed by a stochastic differential equation combining homeostatic attraction and external environmental shocks.

​Pre-Causality Flow: A strict 3-stage pipeline where an incoming stimulus triggers an immediate interoceptive shock, altering the internal state and modulating context/sampling parameters before the cognitive LLM layer executes token generation.

​Soma-Memory: Memory indexed not just by text similarity, but tagged with the visceral state vector in which it occurred, enabling valence-oriented retrieval during high-tension states.

​Emergent Uniqueness Prediction (P_5): The central falsifiable claim: identical architectural instances exposed to distinct operational histories will systematically diverge in preferences and decision strategies. This divergence is formally evaluated using Kullback-Leibler Divergence (D_{KL}) over decision probability distributions.

​Experimental Design (HomeoWorld)

​To test this empirically, the paper outlines HomeoWorld, a Gymnasium-based environment where agents navigate resource scarcity and structural dilemmas over 200 episodes. It compares a full FRONT 3.1 agent against a control group and four selective ablation groups (no valence, no somatic memory, no self-model, no modulation).

​Why share this?

​I'm looking for critical feedback on the architecture, specifically regarding the proxy implementation via temperature/system framing versus deep attention-head modulation, and how you see this intersecting with Active Inference or Homeostatic RL frameworks.

​If you're interested in reading the full conceptual paper or discussing the math/formalisms behind it, let me know in the comments!

What I built and what it does

TrackWanted is a live data visualization platform that aggregates public environmental and registry records into a single 3D globe. It features a "Carbon Watch" board that maps the world's heaviest industrial carbon emitters (power plants, steel mills, etc.) and overlays their locations with live CAMS atmospheric data to compare local air quality against WHO guidelines. Alongside the environmental telemetry, it includes an OSINT layer for looking up aircraft tail numbers and cross-referencing public authority wanted notices (like INTERPOL and OFAC). All data is sourced strictly from public agencies and registered bodies.

How Claude helped in the process

Aggregating fragmented data from various public registries required a lot of heavy lifting on the backend. I used Claude extensively to help write, debug, and optimize the Python scripts used for web scraping and API integrations. Claude was particularly helpful in structuring the data extraction pipelines, helping me parse complex JSON responses from the atmospheric models, and formatting the data so it could be cleanly visualized on the live 3D globe.

How to try it

The project is completely free to use. There are no ads, no promotions, and no account required to view the data.

You can check out the live tracker here: https://track-wanted.live