Semantic Kernel

Semantic Kernel AI

Semantic Kernel AI

Semantic Kernel AI

Semantic Kernel AI

Semantic Kernel AI

Semantic Kernel AI

Semantic Kernel AI

Semantic Kernel AI

Semantic Kernel AI

Semantic Kernel AI

Agents that write their own code at runtime and vote on capabilities, no human in the loop

hollowOS just hit v4.4 and I added something that I haven’t seen anyone else do. Previous versions gave you an OS for agents: structured state, semantic search, session context, token efficiency, 95% reduced tokens over specific scenarios. All the infrastructure to keep agents from re-discovering things. v4.4 adds autonomy. Agents now cycle every 6 seconds. Each cycle: - Plan the next step toward their goal using Ollama reasoning - Discover which capabilities they have via semantic similarity search - Execute the best one - If nothing fits, synthesize new Python code to handle it - Test the new code - Hot-load it without restarting - Move on When multiple agents hit the same gap, they don't duplicate work. They vote on whether the new capability is worth keeping. Acceptance requires quorum. Bad implementations get rejected and removed. No human writes the code. No human decides which capabilities matter. No human in the loop at all. Goals drive execution. Agents improve themselves based on what actually works. We built this on top of Phase 1 (the kernel primitives: events, transactions, lineage, rate limiting, checkpoints, consensus voting). Phase 2 is higher-order capabilities that only work because Phase 1 exists. This is Phase 2. Real benchmarks from the live system: - Semantic code search: 95% token savings vs grep - Agent handoff continuity: 2x more consistent decisions - 109 integration tests, all passed Looking for feedback: - This is a massive undertaking, I would love some feedback - If there’s a bug? Difficulty installing? Let me know so I can fix it - Looking for contributors interested in the project Try it: https://github.com/ninjahawk/hollow-agentOS Thank you to the 2,000 people who have already tested hollowOS! submitted by /u/TheOnlyVibemaster [link] [comments]

Attention Is All You Need, But All You Can't Afford | Hybrid Attention

Repo: https://codeberg.org/JohannaJuntos/Sisyphus I've been building a small Rust-focused language model from scratch in PyTorch. Not a finetune — byte-level, trained from random init on a Rust-heavy corpus assembled in this repo. The run: 25.6M parameters 512 context length 173.5M-byte corpus 30k training steps Single RTX 4060 Ti 8GB Final train loss: 0.5834 / val loss: 0.8217 / perplexity: 2.15 Inference: 286.6 tok/s with HybridAttention + KV cache — 51.47x vs full attention Background I'm an autistic systems programmer, writing code since 2008/2009, started in C. I approach ML like a systems project: understand the data path, understand the memory behavior, keep the stack small, add complexity only when justified. That's basically the shape of this repo. Architecture Byte-level GPT-style decoder: Vocab size 256 (bytes) 8 layers, 8 heads, 512 embedding dim Learned positional embeddings Tied embedding / LM head weights The attention block is not standard full attention. Each layer uses HybridAttention, combining: Local windowed causal attention A GRU-like recurrent state path A learned gate mixing the two Local path handles short-range syntax. Recurrent path carries compressed long-range state without paying quadratic cost. Gate bias initialized to ones so early training starts local-biased. The inference path uses Triton-optimized kernels and torch.library custom ops for the local window attention. Corpus This is probably the most important part of the repo. The run starts with official Rust docs, compiler/library/tests, cargo, rust-analyzer, tokio, serde, ripgrep, clap, axum — roughly 31MB. Corpus expanded to 177,151,242 bytes by fetching the top 500 crates (461 successful clones). Corpus expansion from 31M to 173.5M chars helped more than anything else in the repo. Training AdamW, lr 2e-4, weight decay 0.1, betas (0.9, 0.95), 30k steps, 1k warmup. ~678.8 MiB training memory on a 7.6 GiB card. All experimental memory tricks (gradient quantization, activation compression, selective backprop, gradient paging) were disabled. Small custom architecture + mixed precision + better corpus was enough. Loss curve: Step 0: train 5.5555 / val 5.5897 Step 1000: train 2.4295 / val 2.6365 Step 5000: train 0.9051 / val 1.0060 Step 10000: train 0.8065 / val 0.8723 Step 18500: train 0.6902 / val 0.7757 Step 29999: train 0.5834 / val 0.8217 Best val loss around step 18.5k — overfitting or plateauing late. Inference performance Full attention O(n²): 17.96s / 5.6 tok/s HybridAttention O(n·W + n·D): 0.35s / 286.6 tok/s Speedup: 51.47x — no quality loss KV cache strategy: hot window of W=64 tokens in VRAM (~256KB), older tokens compressed to 8-bit magnitude + angle, selective promotion on demand. Complexity goes from O(n²·d) to O(4096n) for this model. All 5 tests passing: forward pass, generation with/without cache, RNN state isolation, window mechanics. Generation quality Surface Rust syntax looks decent, imports and signatures can look plausible, semantics are weak, repetition and recursive nonsense still common. Honest read of the current state. What I think is actually interesting Four distinct experiments, each shipped working code: Byte-level Rust-only pretraining Hybrid local-attention + recurrent block replacing standard full attention Corpus expansion from core repos to broader crate ecosystem Production-ready hot/cold KV cache paging — 51.47x speedup, no quality loss The clearest win is corpus expansion. The second-order win is that HybridAttention + cache is fast enough for real interactive use on consumer hardware. What's next Ablation — HybridAttention vs local-only vs RNN-only Checkpoint selection — does step 18.5k generate better than 29999? Syntax validation — does the output parse/compile/typecheck? Context length sweep — 256 to 2048, where does window size hurt? Byte vs BPE — now that corpus is 5.6x larger, worth testing? Questions for the sub: For small code models, what evals have actually been useful beyond perplexity? Has anyone seen hybrid local + recurrent attention work well for code gen, or does it usually lose to just scaling a plain transformer? If you had this setup — more tokens, longer context, or cleaner ablation first? submitted by /u/Inevitable_Back3319 [link] [comments]

@Xbox @GearsofWar If you were wondering what to do this June, stop wondering. 👏

@Xbox @GearsofWar If you were wondering what to do this June, stop wondering. 👏

I cut Claude Code's token usage by 68.5% by giving agents their own OS

Al agents are running on infrastructure built for humans. Every state check runs 9 shell commands. Every cold start re-discovers context from scratch. It's wasteful by design. An agentic JSON-native OS fixes it. Benchmarks across 5 real scenarios: Semantic search vs grep + cat: 91% fewer tokens Agent pickup vs cold log parsing: 83% fewer tokens State polling vs shell commands: 57% fewer tokens Overall: 68.5% reduction Benchmark is fully reproducible: python3 tools/ bench_compare.py Plugs into Claude Code via MCP, runs local inference through Ollama, MIT licensed. Would love feedback from people actually running agentic workflows. https://github.com/ninjahawk/hollow-agentOS EDIT: A few people have asked about the OS naming. To clarify: this isn’t a kernel replacement. Think of it the way Android sits on top of Linux, Android developers never write kernel code, they only interact with the Android layer. The goal for Hollow is the same: agents should never need to touch the underlying OS directly at all. Hollow becomes the complete abstraction layer between agents and the system. What’s shipped today is the foundation of that vision, not the finished thing, but even at this stage it delivers a large token reduction and measurable speed improvement with no noticeable loss in precision. submitted by /u/TheOnlyVibemaster [link] [comments]

@davidfowl @aspiredotdev Designing Aspire to be agent-first at the CLI layer is a big move. Fantastic work from the team! Bringing developers and agents into the same interface unlocks a whole new way

@davidfowl @aspiredotdev Designing Aspire to be agent-first at the CLI layer is a big move. Fantastic work from the team! Bringing developers and agents into the same interface unlocks a whole new way to build.

@esz200 😍

@esz200 😍

@ArtemIoha79094 💃🕺

@ArtemIoha79094 💃🕺

@WidmerLuiz We expect this to be your most used emoji now.

@WidmerLuiz We expect this to be your most used emoji now.

@TheRealMariG Available with Windows 11! https://t.co/ozbTvP3lyt

@TheRealMariG Available with Windows 11! https://t.co/ozbTvP3lyt

@ric_shk 👀⭐🌙

@ric_shk 👀⭐🌙

https://t.co/hPczAuiL8J

https://t.co/hPczAuiL8J

Think of datacenter networking like water moving through pipes. Traditional optical cables move data through a narrow, fast stream of light. While Microsoft’s new MicroLED system sends data through

Think of datacenter networking like water moving through pipes. Traditional optical cables move data through a narrow, fast stream of light. While Microsoft’s new MicroLED system sends data through thousands of channels at once – more like a wide, slow-moving river carrying the same volume. The result: a new approach that researchers estimate could use about 50% less energy than mainstream laser-based optical cables, while supporting the massive data flows behind AI and cloud services. Learn how: https://t.co/XVotVfe6uN

@NHL @nba_paint @nba_paint is on a generational run. 👑

@NHL @nba_paint @nba_paint is on a generational run. 👑

@Outlook This is what streamlining feels like 😌

@Outlook This is what streamlining feels like 😌

@Microsoft365 Bringing order to the chaos. 😌

@Microsoft365 Bringing order to the chaos. 😌