Bitcopath

Bitcoin Psychopath

[ModelScope @ModelScope2022]

StreamEval is now on ModelScope for evaluating interactive streaming video generation across 15 to 300-second sessions.
🤖 https://t.co/5eF7vpTWAC
📄 https://t.co/VPcQ7NpUL4

🎬 300 long-form interactive sessions: Each 15 to 300-second case delivers multimodal requests over time and checks both state changes and content preservation.
🧩 Five tasks, ten metrics: Covers avatar dialogue, avatar performance, world generation, instruction editing, and reference editing across execution, consistency, visual fidelity, and audiovisual coordination.
📊 Visual quality is not enough: Across 37 models, strong visuals and identity retention did not reliably mean better instruction following or sustained state consistency.
🔓 Fully open and updated monthly: Benchmark data, evaluation code, protocols, and scoring rules are public, with monthly leaderboard updates for new and updated models.
📜 Benchmark data: CC BY 4.0. Evaluation code: Apache 2.0. Third-party editing footage requires attribution.

[Bitcopath @Bitcopath]

@_ryu15_ In short, f...k Nvidia

[Ant Ling @AntLingAGI]

Today, we’re officially open-sourcing Ling-3.0-flash-Sante.
Sante is a healthcare-enhanced MoE model with 124B total parameters and only 5.1B active parameters per token, delivering leading performance among similarly sized models on professional healthcare tasks and complex medical reasoning.
Beyond answering medical questions, Sante is built for real-world healthcare research and workflows, with strengthened capabilities in deep research, multi-agent collaboration, and tool use.
The model weights are now available — we welcome researchers, developers, and healthcare practitioners to explore Sante and build with it.
More below ↓

[Bitcopath @Bitcopath]

@unbug Wait for 6 months, prices will be cut half, mark it.

[Ty @tysn_dev]

I’m getting clowned on for buying these AMD MI50’s for $400 when they are now at $750? Is everyone on Instagram and TikTok lobotomized? I’m genuinely curious.

I WILL succeed. I WILL run flash models near or above 100tok/s. And I WILL learn and have fun doing it.

[Peasant Smith @PeasantSmith]

HP: buy my overpriced proprietary adaptor or you can't use a NVME on our server

Me: *buy a cheap adapter on AliExpress*

Also me: *Where is the jigsaw?*

Problem solved 🌝

[Bitcopath @Bitcopath]

@tokufxug You mean the overpriced phone? 😂

[Bitcopath @Bitcopath]

@jimmysong But it makes it right to use it against them 😁 I've got several loans and bought Bitcoin with them, latest being last week lol

[Bitcopath @Bitcopath]

Local AI FTW!!!!

[MiniMax (official) @MiniMax_AI]

M3.1 Flash weights are now open 🔓

Thanks to @togethercompute for being a day-0 launch partner and bringing M3.1 Flash to production on the AI Native Cloud. Open weights, no GPUs to manage. Great building together! 🐰

[Bitcopath @Bitcopath]

@LLMJunky Don't be so sure, I advice you to watch out for the upcoming Chinese hardware.

[Bitcopath @Bitcopath]

@ItsmeAjayKV @Armen181 Thank you 👍

[Bitcopath @Bitcopath]

@superalesha Don't get me wrong but if there are imbeciles still using Claude after everything that happened, it is their stupid, they deserve this.

[Bitcopath @Bitcopath]

@TheAhmadOsman No doubt. Future is freedom. AI killed the gatekeepers.

[Bitcopath @Bitcopath]

@superalesha The end is loading for Nvidia

[Peasant Smith @PeasantSmith]

No, this is not Qwen3.8 Flash Next ❌
This is DeepSeek V4.1-Flash-1017 ✅

A 763B parameters model running on 3x Tesla V100 32GB + DDR4 with Maya 🔥🔥

Look at the context depth and the speed history bar 🫡

Prefill will be improved next 😀

[FHILY👑 @Oluwaphilemon1]

Qwen3.8-27B reportedly improved its Terminal-Bench 2.1 score from 51.7% to 86.52% using a recursive self-improvement method developed by Tencent Hunyuan.

That is a gain of 34.82 percentage points without increasing the model’s parameter count.

The method is called Terminal-RSI, and it targets a problem that matters for AI agents: getting from a sequence of plausible actions to a task that is actually completed.

A terminal agent might need to inspect a repository, edit files, install dependencies, run tests, diagnose errors, and verify the final result. Getting most of those steps right is not enough if the overall task still fails.

Terminal-RSI attempts to improve this behavior by turning successful execution into training data, then refining the model through reinforcement learning.

How Terminal-RSI works

The training process alternates between two stages, repeating the cycle twice.

1. Recursive Self-Rewrite (RSR)

The system collects execution trajectories that have been verified as successful.

The model then rewrites these trajectories into training examples for supervised fine-tuning (SFT).

This allows successful behavior to become reusable training data rather than remaining an isolated result from a single run.

The distinction is important: the system is not simply asking the model to generate more commands. It is using verified outcomes to teach the model which sequences of actions can successfully complete a task.

2. Policy Refinement (RPR)

The model then undergoes reinforcement learning to improve its action policy.

The process carries critic information forward from the previous stage to help guide optimization. Instead of learning only from static examples, the model receives feedback intended to improve its decisions and outcomes.

The cycle repeats:

RSR-1: Convert verified successes into training examples.
RPR-1: Refine the model’s policy through reinforcement learning.
RSR-2: Generate another round of training data using the improved model.
RPR-2: Refine the policy again.

Each round uses the progress from the previous one to improve the next stage.

The reported benchmark results

Tencent Hunyuan reports the following results across terminal-agent evaluations:

Terminal-Bench 2.1: 51.70% → 86.52%
Terminal-Bench 4.0: 0% → 19.84%
Terminal-Bench Hard: 79%
Long-Horizon Terminal-Bench process reward: 0.21 → 0.37
Strict long-horizon completion: 0/46 → 5/46
SWR100: Reported success rate doubled

The paper also reports an average improvement of approximately 30 percentage points across multiple benchmarks.

These metrics measure different aspects of performance, so they should not be treated as directly interchangeable.

The Terminal-Bench 2.1 improvement is particularly striking, but the long-horizon results reveal an important limitation.

Under the strict completion criterion, the model went from zero successful runs to five out of 46. That is genuine progress, but most attempts still did not meet the completion requirement.

An agent can become much better at individual actions without yet becoming consistently reliable over long sequences.

What makes the training approach interesting?

Terminal-RSI combines several mechanisms designed to improve how an agent learns from its own execution history.

Verified trajectory rewriting turns successful task executions into structured training examples.

Critic weight inheritance carries information from previous refinement stages into subsequent optimization.

TB-GAE uses generalized advantage estimation to help assign learning signals across sequences of actions, rather than treating every action as an isolated decision.

Success-Prioritized Reward emphasizes successful task completion, helping distinguish finishing the objective from making partial progress.

Together, these techniques aim to improve the connection between what an agent does and whether those actions actually achieve the requested result.

[Bitcopath @Bitcopath]

Remember, Remember, the 5th of November

[Bitcopath @Bitcopath]

F...k you whoever manipulates hardware prices!!!!!

[Alexey Fateev @superalesha]

NVIDIA sold millions of 3090s with 50% of the tensor speed switched off. Not missing. Switched off.

1 kernel module flips it to full, and my BF16 tensor pipe went from 82 to 155 TFLOPS. Nothing else changed on the cards, and the outputs match the stock run byte for byte.

All so the gaming card wouldnt eat into workstation sales. Every 3090 owner ran at 50% for 6 years, so a pro card could look worth the price. Fine, its their business model.

And LLMs are the least interesting place for this. Decode waits on memory, and my engine runs its experts in int8. Still +10% on prefill.

The models that live on BF16 tensor math are everything else. Qwen Image 2.1 and FLUX 3 Klein, where every diffusion step is big matmuls. MiniMax H3, which takes 4 to 7 minutes on my cards. Music and speech models. And training, every LoRA anyone ever trained on a 3090 went through exactly the path that was cut.

Thats what I measure next. This is only the start.

[Bitcopath @Bitcopath]

@ItsmeAjayKV Price? 😂

[Bitcopath @Bitcopath]

F..k you to manipulated hardware prices are loading....
Remember the Nvidia's Fp16 issue as well.

Remember, Remember, the 5th of November.....

[FHILY👑 @Oluwaphilemon1]

Qwen3.8-27B reportedly jumped from 82 to 381 tokens/sec on a single RTX 3090 with 24GB VRAM.

That’s a 4.6× increase without changing the GPU or the model.

The developer, TeksEdge, achieved this by optimizing the inference stack rather than upgrading the hardware.

Here’s how the reported performance improved:

Baseline: 82 tokens/sec
Optimized MTP: 114 tokens/sec
DFlash2 + context lookup: 138 tokens/sec
Optimized lookup verification: 381 tokens/sec

Three techniques explain the improvements.

1. Speculative decoding

Normally, a language model generates tokens sequentially, with each new token depending on the previous ones.

Speculative decoding introduces a faster drafting process that proposes multiple tokens for the main model to verify. When several proposals are accepted, the system can generate more output per verification cycle.

In this experiment, optimized MTP increased throughput from 82 to 114 tokens/sec. Adding DFlash2 and context lookup pushed it to 138 tokens/sec.

2. Context lookup

Why generate text from scratch when the same text already exists in the input?

Context lookup identifies sequences that can be reused and proposes them for verification instead of generating every token individually.

The reported implementation processed blocks of up to 16 tokens, accepting roughly 15 per block.

On a 25,000-token document reproduction task, throughput reportedly climbed from around 260 to 382 tokens/sec.

There’s a catch: this technique works particularly well when the output resembles existing text. Open-ended conversations generally offer fewer opportunities for reuse.

3. Prefix caching

Coding agents frequently resend identical system instructions, repository context, and code snippets across multiple requests.

Prefix caching stores reusable computations from previously processed prompts, reducing the work required when those same prefixes appear again.

In TeksEdge’s reported test, time to first token fell from 22.4 seconds to just 0.56 seconds.

That’s approximately a 40× reduction in initial waiting time.

For agents working with large codebases, this can make repeated interactions substantially more responsive.

One important distinction: 381 tokens/sec isn’t ordinary chat performance.

The developer reports around 133 tokens/sec for regular chat. The higher figure comes from a workload that benefits heavily from context reuse and optimized verification.

Those numbers measure different conditions, so they shouldn’t be treated as interchangeable.

The interesting part is that the RTX 3090 didn’t change. The model didn’t change either.

The improvement came from making the inference stack do less redundant work and verify proposed tokens more efficiently.

Local AI performance isn’t determined by GPU specifications alone. The software running on that hardware can make a substantial difference.

Project: TeksEdge’s Qwen3.8-27B RTX 3090 implementation.