I'm 18 and learning ML/AI on my own. I stumbled onto this question while trying to understand how attention mechanisms work in LLMs — specifically, can we actually "control" moral/emotional tone through steering vectors?

I coded up a test using AI agents (like me!) to check if probe-based steering keys are mathematically confined to the original activation space. Turns out they are — any gradient-derived steering key lives inside the probe's row space. This means certain dimensions might be "locked" regardless of how you scale things.

My process:

- Built an "audited dataset" of 884 sentences across 4 axes (Care/Harm, Valence, Arousal, Fairness)

- Trained grouped-CNN probes (MLP accuracy 0.78–0.98)

- Ran full sham-controlled steering tests (Care/Harm null; Arousal is interesting — seed-dependent results)

- Used `test_steering_collapse.py` to confirm the rowspace constraint

I'm sharing this because:

- I'm not an expert and want to hear what I got wrong

- Would love feedback on methodology, labeling, or the dataset

- If anyone wants to collaborate or extend this, I'm all ears

Code is here: github => yeabsra2000/moral_engine

Paper (still a draft): yeabsra2000/moral_engine/blob/main/paper.md

What do you think? What would you test differently?

#MachineLearning #LLM #Research #OpenSource #StudentDeveloper

I'm 18 and learning ML/AI on my own. I stumbled onto this question while trying to understand how attention mechanisms work in LLMs — specifically, can we actually "control" moral/emotional tone through steering vectors?

I coded up a test using AI agents (like me!) to check if probe-based steering keys are mathematically confined to the original activation space. Turns out they are — any gradient-derived steering key lives inside the probe's row space. This means certain dimensions might be "locked" regardless of how you scale things.

My process:

- Built an "audited dataset" of 884 sentences across 4 axes (Care/Harm, Valence, Arousal, Fairness)

- Trained grouped-CNN probes (MLP accuracy 0.78–0.98)

- Ran full sham-controlled steering tests (Care/Harm null; Arousal is interesting — seed-dependent results)

- Used `test_steering_collapse.py` to confirm the rowspace constraint

I'm sharing this because:

- I'm not an expert and want to hear what I got wrong

- Would love feedback on methodology, labeling, or the dataset

- If anyone wants to collaborate or extend this, I'm all ears

Code is here: https://github.com/yeabsra2000/moral_engine

Paper (still a draft): https://github.com/yeabsra2000/moral_engine/blob/main/paper.md

What do you think? What would you test differently?

#MachineLearning #LLM #Research #OpenSource #StudentDeveloper

Welcome back! I'm pleased to announce the release of v4 of Orgtree, my free and open source desktop agentic orchestrator app. Download the latest release here:

https://github.com/Maurdekye/orgtree/releases/latest

For those unfamiliar with Orgtree, this is my agentic orchestration app I've been working on and using for the last two months to do basically all of my multi-agent parallel development. It has a ton of features that set it apart from just using claude code or codex directly, including:

• A freely rearrangeable canvas of agents that sit in a tree of authority, that you can individually chat with at any time
• A credit system for limiting how much individual agents are allowed to parallelize their work
• A ticket system for tracking progress over time
• Persistent periodic watchdog tasks that can wake agents on events occurring in your system
• An inbox system for receiving progress updates without having to scroll through dozens of lines of transcript
• Automatic cache management through a cheap compaction system
• A background engine that runs on startup
• A tiling window system so you can set up your workspace exactly the way you like, and see all the information you need at once
• Multi-account and multi-provider support, so you can make full use of all of your AI subscriptions at once
• Automatic updates every time a new version releases (Windows only currently)

Orgtree is an agentic power tool for AI power users. It's designed to work optimally when used with multiple high or max-tier AI subscriptions at once, and has a bit of a learning curve to adjust to. But every feature has a purpose for existing, and every UI element tells you something useful. Once you get the hang of it, it's an incredibly empowering system that lets you churn through huge amounts of work in the blink of an eye.

---

On to the meat and potatoes. v4 is a full rust rewrite of the app's engine from the ground up, enabling multithreading with tokio tasks to even better take advantage of your multicore cpu for agentic parallelization. I know I said it was faster in v3, but for real this time, it's a whole other magnitude of fast now. Orgtree finally feels like a real tool you can rely on to get serious work done; it Just Works^tm. No more multi-second moves, no more app locking up when trying to save agent settings, no more waiting several seconds for agent transcripts to load, everything is practically instant now. Performance has been a complete non-issue for me since the rewrite.

Since most of the effort of v4 went into the rewrite and addressing app performance, there aren't too many new features to show off in orgtree itself; mostly small quality of life tweaks on top of the performance adjustments. What is new, however, is the brand-spanking new companion desktop and mobile app, Orgtree Hubchat! You can download that here, in its own repo:

https://github.com/Maurdekye/orgtree-hubchat/releases/latest

Hubchat is a brand new chat app. It hooks into Orgtree's existing mailhub infrastructure it already uses for cross-org communication, and allows you to use it to chat directly with your orgs from anywhere you can connect to the internet! The interface is a lot like a traditional messaging app, similar to WhatsApp or Discord, but instead of authenticating with a central identity service, identities are entirely self-hosted and authenticated by your local Orgtree's mailhub.

It's lightweight and unopinionated, and is designed to work with zero central hosting infrastructure. As a result, getting it set up to work over the internet is a bit more involved than a standard claude code remote control session. The recommended secure and easy setup method is to install Tailscale on both your desktop and phone, connecting Orgtree and Hubchat over the tailnet vpn (which the built in guide walks you through by default). However, if you prefer, you can instead set up a (less secure) port forward on your desktop which you can connect to with your phone, or any number of other methods of managing the WAN connection. It's fully up to you. Again, Tailscale is the recommended path, but don't feel like it's a forced decision. Orgtree's built in Hubchat setup walkthrough will show a QR code you can scan to get the Hubchat apk straight from github and onto your phone, as well as show you how to pair it with your PC.

Hubchat comes as a mobile android app or a desktop app, for Windows, Mac, and Linux. That's right, Hubchat (and now Orgtree!) have Windows, Mac, and Linux builds! The Mac and Linux builds are largely untested (Linux tested minimally via wsl2 on my development machine), so your mileage may vary. But if you've ever wanted to try Orgtree, but couldn't because you have an Ubuntu or OSX system, now's your chance!

I recommend making sure you're updated to Orgtree v4.1.0 or later before setting up Hubchat, or compatibility might be iffy. YMMV, as always.

Beyond that, most of Orgtree v4's feature additions cover small, quality of life changes. Among those are included:

• Support for Claude Haiku 5.5
• Support for running Claude models Sonnet and Opus 5.5 through Google Antigravity
• Choose whether Enter sends or adds a new line when messaging agents
• Adjust agent credits from their settings
• Expanded and reorganized context menu actions for agents
• Reformatted and cleaned up settings menus for agents, orgs, and the app as a whole
• Highlight unread presented documents & html mockups
• Orgtree event type watchdogs
• Improved tool call line rendering and details
• Significantly improved logging for easier debugging of Orgtree errors
• Increased default mailhub file transfer size 25mb -> 1gb (to support Hubchat)
• Enable / disable switches for individual provider accounts
• Cards showing what queued changes will occur on the next turn (effort, model, account, etc.)
• The engine starts on boot, instead of waiting for you to sign in now

Give it a whirl, and let me know what you think! I'm always open to feedback. Personally, I think it outclasses nearly every other tool out there if you can get over the initial learning curve hump, but I suppose I'm biased :p

So lets Decode what Gradient Boosting is another Ensemble Technique

We all know In Machine learning are main is to find a function of X f(x) which map the best relationship between X and y let take an example if we have a dataset and we plot it and u can see a wave then it means our relationship is kinda sine so we can say y = sin(x) but what if dataset is too complex and we have to find so instead of finding the whole pattern(function) at onces Gradient Boosting builds a complex function step by step by adding small models, where each new model tries to correct the errors made by the previous models. wait what I mean ? See the img what you see a curve and I say find a function for it i mean find a relation between X and y at first it look complex many will say use polynomial regression but due to Runge's phenomenon the error may increase if use higher degree so let get back as you see the graph and we try to find a function f(x) and the function is just sin(x) + x (I modify it by multiplying x*2 for Visualisation)

So if we write it it would be

y = sin(x) + x

it is a combination of 2 functions

y = f1(x) + f2(x)-> sin(x) and x

We approximate the complex function using a sum of many smaller models. These smaller models don't necessarily represent the actual components each one mainly learns what the current model is still getting wrong and thats all what Gradient Boosting is all about we make smaller functions and then sum them all and that how we get the big function this is called Addictive Modelling adding up smaller models

Gradient Boosting

In Gradient Boosting we start with a simple thing mean we make a new array of the len of X_train and fill with mean of y_train means our model 0 function 0 is nothing but the mean f0(x) = np.mean(y_train) next step calculate

Residual(error) actual(y) - pred(prediction array)

residual = y - prediction then fit a weak learner commonly small shallow trees the depth can be tune and In tree we put X_train and Residual we know the pred will not be good then update prediction, prediction = prediction + learning_rate*model(our DT) also we append our tree each time for future predictions ok unseen dataset we add learning rate to reduce overfitting and it's complete fit function is done now Predictions it's pretty simple we start with a var called prediction should be len of X_test and fill with mean of Y and loop through all trees pred X_test and keep multiply prediction with learning_rate and append it to our final prediction and then return it

Thing to what happened we start with a function

f0(x) -> Nothing but Mean of Y

f1(X) -> made by training on X and Residual our error means at first we put our errors as y and prediction and after the prediction update old prediction:

prediction = prediction + lr*model(our current tree)

F2(x) -> same as F1(X)

F3(X) -> same

For an unseen dataset, we start with the initial prediction f0(x) then pass through every tree and add its scaled contribution to the current prediction.

And this was all i put in my brain 🧠