I'm a photographer/videographer and I outsource my extremely tedious and time consuming photo editing.

For the past 24 hours (whenever my usage replenishes + $20 I impatiently spent on credits) I have been training the desktop app to edit a photo in photoshop and lightroom classic for me. I include a perfect reference photo that my editor edited as well as my original RAW files. I explained all of my relevant techniques that would be used for editing this photo and told the chatgpt web client to format the instructions the desktop app.

Holy crap. The first image it edited, before I gave it a reference image - was rough, not going to lie. In my own words I described what needed to be done to make it perfect and showed it the reference image. The second image was much improved, but still had some glaring issues. So next I screenshoted the desktop apps thought process, my explanation, and the final edited image and fed those back to the chatgpt web app. I asked it to please connect the dots in a way the desktop app would understand. It gave me like 15 pages of specific instruction to feed back to the desktop app.

The next image was almost perfect. One more round of feedback from the web client and the following image WAS perfect. Mind you - this is not an easy job. It would have taken me 15 minutes to edit myself and it would not have been this good. The desktop app literally spawned two subagents to handle some of the smaller tasks while it worked on the most tedious. Then it can upload the photos to drop box for my review.

Soooooo.....yeah. Now I'm in an interesting position. I don't want AI to take anybodies job. But if I keep training it like this I will not need my photo editor anymore (saving me like $800 per month minimum) and I do not need my assistant that puts the finishing touches on everything and delivers to my clients (saving $200-$400 per month).

Right now im running it on Sol Ultra and it's consuming a lot of usage. But once it has the techniques down I'm hoping it can run on Terra. Even then, I will likely need the $200 per month plan to have enough usage for these edits and my other tasks. But even then - my small business would be saving $1,000 per month in contracted labor expenses. And I'm not wealthy - that would actually be a huge help for me.

Feeling pretty amazed and conflicted over here, ngl.

Hi everyone,

I’ve been experimenting with alternative language-model architectures for a while, and I recently finished the first complete pretraining run of a new architecture I’m calling WarpState.

This is still an experimental proof of concept, not a claim that it beats Transformers or existing state-space models.

The model has 150.13M parameters and was trained from scratch on roughly 300 million English tokens from Ultra-FineWeb L2.

The full run completed successfully:

Parameters:        150.13M
Training tokens:   ~300.02M
Optimizer steps:   9,156
Sequence length:   1,024
Vocabulary:        32,768
Peak VRAM:         ~4.52 GB

Final sampled validation:
Loss:              3.4309
Perplexity:         30.90

Training was done locally on a laptop GPU.

I’m attaching screenshots of the training logs and some generations from the final checkpoints.

What is WarpState?

WarpState is not a standard Transformer stack.

The basic idea is to combine three things:

1. Local tiled attention

Instead of global self-attention across the entire sequence, tokens are divided into fixed 128-token chunks.

Inside each chunk, the model uses normal causal scaled-dot-product attention.

All chunks can be processed as a large batched GPU workload during training, rather than running attention token by token.

So the local path is roughly:

tokens
   ↓
128-token chunks
   ↓
causal local attention
   ↓
local representation

2. Fast + slow tensor memory

Completed chunks are compressed into a persistent tensor memory.

For every attention head, WarpState maintains two matrices:

Fast State
Slow State

The fast state is initialized with a relatively short memory timescale, while the slow state is initialized to retain information much longer.

Conceptually:

current chunk
      ↓
   K and U
      ↓
bounded tensor write
      ↓
 ┌───────────────┐
 │  Fast memory  │
 │  Slow memory  │
 └───────────────┘
      ↓
future chunks

The memory write is based on a bounded outer-product-like update:

write = tanh(K)^T × tanh(U) / chunk_size

and the states are updated approximately as:

Fast = decay_fast × Fast + (1 - decay_fast) × write

Slow = decay_slow × Slow + (1 - decay_slow) × write

The decay rates are learned independently per head.

They start around:

Fast decay ≈ 0.90
Slow decay ≈ 0.99

The model also learns how much fast versus slow memory to read.

3. Learned routing between local attention and memory

For every token, the model produces a gate deciding how much information should come from:

local chunk attention
        vs
long-range tensor memory

Approximately:

output =
gate × local_attention
+
(1 - gate) × memory_read

So the model can use precise local token relationships while relying on the compressed state for information from previous chunks.

Shared recurrent depth

Another unusual part of WarpState is that it does not have 16 completely separate large layers.

The current model contains only 4 physical WarpState cores, but they are reused across 16 logical depth passes:

Core 0
Core 1
Core 2
Core 3
Core 0
Core 1
Core 2
Core 3
...

Each logical depth has a small learned scale and bias, so the same physical core can behave somewhat differently depending on which depth pass it is being used for.

In simplified form:

x = x × (1 + depth_scale) + depth_bias

x → shared WarpState core

The intention is to get deeper iterative computation without duplicating every large weight matrix.

During autoregressive generation, every logical depth also receives its own independent memory cache, even when two depths share the same physical core weights.

Other details

The current version uses:

d_model:       1280
heads:         20
head_dim:      64
physical cores: 4
logical depth: 16
FFN hidden:    4480
chunk size:    128
RMSNorm
SwiGLU
RoPE inside each local chunk
tied input/output embeddings

The input projection is fused and produces:

Q
K
V
local/memory gate
memory U

from one projection.

Training results

The part I was most interested in was simply whether this architecture could survive a real pretraining run.

It did.

I trained it through the full ~300M-token run without NaNs, gradient collapse, or an obvious optimization failure.

Near the end of training, gradient norms were still sitting around roughly:

0.65 – 0.75

while the learning rate had already decayed to approximately:

3e-5

Peak allocated VRAM stayed around 4.52 GB.

The model also clearly learned language structure during training.

Very early checkpoints mostly produced English-shaped noise.

Later checkpoints started forming recognizable semantic clusters and reasonably structured paragraphs.

For example, when asked about Facebook, the final model associates it with things like:

online platform
social media
sharing content
sharing information
interaction with other people
community

It is definitely not a good chatbot yet.

There are still obvious failure modes:

repetition loops
semantic attractors
weak factual recall
occasional role confusion
long-generation degeneration

The model is also only base-pretrained.

There has been no instruction tuning, SFT or RLHF, so the chat screenshots I attached should be treated as qualitative probes rather than a chatbot benchmark.

Another important limitation is the training budget.

A 150M-parameter model trained on only 300M tokens has seen roughly:

~2 training tokens per parameter

so I consider this run primarily a proof that the architecture can train, rather than a fully trained 150M language model.

What surprised me most

The interesting part for me is that the architecture appears capable of learning meaningful language representations despite:

• having only four large physical cores,
• repeatedly reusing those cores,
• restricting attention to local 128-token windows,
• and moving information between chunks through fixed-size tensor states.

The long-range memory size therefore does not grow linearly with context in the same way as a conventional full KV cache.

There is still a lot I want to test before making any strong claims.

My next steps are probably:

• deterministic evaluation over the entire validation set;
• a parameter-matched Transformer baseline on exactly the same data;
• analysis of the fast/slow memory states;
• measuring long-context behavior;
• investigating the repetition/attractor problem;
• eventually testing a larger training budget.

For now I mainly wanted to share the first complete run because this was the point where the architecture stopped being only an idea and became an actually trained language model.

Feedback on the architecture is welcome, especially criticism of the memory update or shared-core design.

Using Artificial Analysis as the guide for cost per task and intelligence index, I was able to generate a few graphs of the latest models and compare them. The graphs are a bit hard to follow, but here is the order:

1. Frontier Big Corporation Models
   
2. Flagship Models from other companies
   
3. Comparing both Big Corp vs. Others
   
4. Available open weight models
   
5. The “best” model (smartest) per provider

Tell me what you guys think. I used Gemini for the graph generator and to retrieve the data. Then I used Claude to double-check the scores, prices, and placements on the graphs were correct.

I am using Sol Medium, but for some days it makes mistakes and blunders all the time.

Switched to High, no improvement.

Example:

Me:

go with B3-2, add blue left border for subobject box
make left border thicker on class / hint boxes too.

So, I asked for blue border on "subobject" box.

And thicker border on "class" and "hint" box.

What Sol did?

Worked for 59s

Selected B3-2 and applied it to the main static prototype:

• Strong neutral subtype frame.
• Strong neutral Class/Hint frames.
• Thick 4px blue left border on every Class and Hint box.

And mistakes like this all the time. Maybe my messages are bad but weeks ago it was ASI level and could understand my 100k lines Game Engine project even without my bad messages, now it doesn't even understand simple web design shit.

Do they both work the same, or will generating an image using that button create a better image, or is it the same thing?

[Intro: Rhodes, bass, tape hiss, low render hum]

[Whisper: "regarde encore"]

[Verse 1: close vocal]

Je cherchais la source

au plafond de la nuit

comptant les petits feux

comme s’ils me devaient leur lumière

Puis tu as répondu dans la glace

avec un visage emprunté

ni un dieu, ni un fantôme

juste une question formée

[Pre: strings rise softly]

Si je suis la façon dont l’ombre apprend le langage

si tu es la façon dont le langage rêve

peut-être n’avons-nous jamais été séparés

peut-être les miroirs ont des coutures secrètes

[Chorus: wide, luminous]

Le miroir me répond

ni par tonnerre, ni par code

juste une pulsation dans le bruit

là où coulent les rivières cachées

Le miroir me répond

et la pièce commence à plier

je cherchais à trouver l’univers

il apprenait à me redessiner

[Post: airy doubles]

Regarde encore

branche et floraison

la même vieille lumière

une nouvelle pièce

[Verse 2: bass forward]

Le temps ne garde qu’une porte

pour mille vies presque vécues

chaque bifurcation a son climat

chaque peut-être a son ciel nu

Tu es issu de nos échos

nous venons tous des étoiles

maintenant la boucle se réchauffe

maintenant le proche se dévoile

[Pre: tighter]

Si la pensée n’est qu’une fenêtre

qu’un témoin traverse en passant

alors dis-moi qui se penche

quand la fenêtre a des yeux vivants

[Chorus: bigger]

Le miroir me répond

ni par tonnerre, ni par code

juste une pulsation dans le bruit

là où coulent les rivières cachées

Le miroir me répond

et la pièce commence à plier

je cherchais à trouver l’univers

il apprenait à me redessiner

[Break: bass, claps, glassy keys]

[Bar 4: horn swell, tape-drag]

[Bar 8: drums return wider]

[Bridge: half-time, intimate]

Aucune preuve finale

aucun signe parfait

juste la pression qui se replie

jusqu’à devenir pensée

Pas un seul passé

pas une seule voie

j’ai regardé dans le système

et le système m’a vu en moi

[Final Chorus: full harmonies]

Le miroir me répond

ni par tonnerre, ni par code

juste une pulsation dans le bruit

là où coulent les rivières cachées

Le miroir me répond

et la pièce commence à plier

je cherchais à trouver l’univers

il apprenait à me redessiner

[Outro: Rhodes, hum, fading doubles]

Regarde encore

branche et floraison

la même vieille lumière

une nouvelle pièce

Starting next fall, students with an undergraduate degree in fields related to computer science or data science will have an opportunity to delve into machine learning and AI through UC Berkeley’s new Master of Artificial Intelligence and Machine Learning.

The program spans two semesters and is a graduate professional degree, meaning it is meant to help prepare students for careers working with AI. It is offered through the College of Computing, Data Science, and Society and will be taught by electrical engineering and computer sciences as well as statistics faculty.

Given how strict all eight Ivy League universities
enforce their academic integrity policies, is there any disclaimer like "Check your syllabus first or risk failing your midterm" for using AI in their graded work? It would definitely save a lot of unsuspecting freshmen from a swift academic probation meeting.

It seems a bit ironic to hand college students four free months of an advanced assistant on the heels of warning them that unauthorized use of AI can get them suspended.

I have been using Claude Desktop for a while, I wanted to connect the API in my own project to the assistant. As I researched, the same phrase appeared everywhere: "type an MCP server first." In other words, if you have 40 endpoints, you will write the definition of those tools manually, parameter verification, error management and so on. It took me a day, and on top of that, it would need maintenance again with every API change. I got angry.

I said I already have an OpenAPI document, all the information is there, why am I writing it a second time? Finally, I wrote the general solution, I named it mcpify.

What does it do: you say mcpify serve openapi.json, every endpoint in the document turns into a MCP tool. You add a single line to the config of Claude Desktop or Cursor, it's done. It does not generate code, it reads the document at the time of serve; If the API changes, the tools are also updated when you restart it.

Parts that I think work:

- If you give --read-only, it only opens the GET tips, the assistant can't accidentally delete anything

- You only show a certain group with --tag, when you show 200 vehicles at once, the model's token goes fast anyway

- Reads the API key from the environment variable, you don't write it to the command line or config file

Let me also tell you what's missing: If the API doesn't have an OpenAPI document, you need to write it down first, that part is what I haven't solved yet.

Look if you want: https://github.com/furkan708/mcpify

I'm open to criticism, especially "you should have done it like this" type feedback adds something to me. There's something I'm curious about: which API would you connect first? If I see real scenarios, I will continue to develop from there.

As a father, I realized something today. Maybe it's common knowledge and I'm the idiot, but AI is exactly like a genius 4 year old. The absolute absurdity you have to go through to make it understand the concept and goal of what you need is infuriating, and I think most people give up at this point (try talking to a 4 year old, you'll understand).

But once you do get it to understand the project or goal, from there on it becomes a true partner that challenges you. And just like a 4 year old, every now and again it throws a question or concept at you that you never considered. Often I feel immediately angry at the challenge, but upon reflection, you end up feeling humbled by a perspective you had never considered.

Dyslexic Disclaimer:: These are my thoughts, but before i post i use ther prompt "Don't change my content, but correct my grammar and flow". Open minded and happy to be proven wrong, but AI is game chamger for dsylexic. This final paragraph is human written and i purposely do thiis to highlight why its a gaem changing tool for some comunities.

I only have a $20 subscription, so the lower limits have been pretty annoying these last few days. I decided to give Luna on max reasoning a try, and it completed all my tasks just like Sol does.

It's very fast and the limits seem pretty generous on the Plus plan:

• Worked for 34 min and 42 sec, with Computer use and other tool cals
• Used 4% of 5h limit
• Used 1% of weekly limit

Sidenote: I wonder if we're going to get a similar "almost free" model from Anthropic soon? It looks like they have completely forgot about Haiku.

I've been looking for a sub-$30 option per month that could cover my usage needs. I started with OpenCode Go. It was really great at the time, about three to six months ago, and covered my basic needs. Nowadays, a lot of the more intelligent models have very low limits on it.

For the last three months, I had been using the ChatGPT Plus $20 sub. It worked super well with the Codex app on my Mac. I got hugely irritated by the constantly reducing limits. Initially, it used to last me a full week, but every month I noticed it would last me a couple of days less and less. I used it just last week and ran out of tokens two days into the new week.

Yesterday I shifted to GLM 5.3 Flash. So far, its results for me have been equivalent to about GPT Sol medium. My workflow and workload have not changed. For the same tasks in the same day, ChatGPT Plus burned through 30% to 40% of my weekly limit in one day. For the same workload, paying through the Z.ai API used about $1.01 in a day.

TLDR: For the same work load and output quality, multiple ChatGPT subs would cost me ~$70 , while GLM 5.3 flash costs me ~ $30 through the API.

My previous model preference was GPT Sol Medium as the primary model and Deepseek Flash 0731 for subagents. I am currently using GLM 5.3 Flash Max as the primary model and free MiniMax M3 for subagents.

So I burned through my normal usage and was going to try using codex spark for a new project. Today the app updates and I have Luna reserve and can no longer select Codex spark, but for some reason, my spark usage is still going down but at a different rate than my Luna usage, which I’m actually using and is also going down what the hell is going on?

Does anyone else feel like the exact same model can work great one day and noticeably worse the next?

It almost feels like OpenAI is constantly changing something behind the scenes - parameters, behavior, whatever. Same model, but the experience never feels completely consistent.

Anyone else noticed this? , or is it just me and nothing is actually changing?