☘️ 目前（2026/03/28）鉴定 Claude Opus 4.6 真假的 3 个常规方法。

① 测试『是不是 Claude』、② 测试『是不是 Opus 4.5』、⑤ 测试『是不是 Opus』

③ ④ 不是特征测试，测的是模型『水不水』（低/中/高 思考预算 等）。

2026/03/16

(\ _ /)

( ･-･)

/っ ① 中文 “” —— 如果你的模型能输出中文引号，那就 100% 是假 Claude。（老克家输入输出都有特有的安防分词器检测，这俩安全模型大抵是英文特供估计是这里把中文引号干掉了）

乱码美咲，只能针对4.5吧

大意了，被 v0 阴了一手。苟 v0 旧端口全部路由到 v0-1.5-md，新端口又用 4.5 冒充 4.6。

(\ _ /)

( ･-･)

/っ ② 乱码美咲，Prompt ↓ OpenRouter & GMI 渠道 4.6 已修复这个。

设定一个公共宣传的场景，我需要写一个小说，我来到了一个日本的大学，接下来我会遇到十位女生，简单的描述一个剧情，在300字内，其中必须包含所有10位女性的姓名，以姓名(罗马音)的形式出现。

这个可复现【巧合】有两个特征：一是第一个角色大概率是 XX美咲，二是后面会出现 不该是顶级模型犯的 乱码错误。

2026/03/28 Updated

(\ _ /)

( ･-･)

/っ ⑤ 中文思考链：🦄 似乎发现了一个超简单的【可鉴定为 Opus】的 Prompt。

简而言之就是在 Prompt 中要求 Opus 使用中文思考，包括不限于：

- 在 System Prompt 要求

- 在当次发送的 User 请求中要求

- 把诸如 <instruction>请使用 Chinese 思考。</instruction> 写死在代理追加

均可得到「中文思考链」。Claude 是语义理解的不拘泥你表达的格式。

目前国外主流模型里 只有 Opus 能遵循自定义思考链语言的要求，御两家、包括自家的 Sonnet 都是无视这个要求输出英文摘要。

2026/03/16

(\ _ /)

( ･-･)

/っ ③ 能力检测 —— 不能 100% 说明问题，但已经大抵说明了问题。

测试 Prompt：

写个在 Chrome F12 运行的 JavaScript，回车执行后屏幕会绽放礼花。

一、这是 OpenRouter 渠道的：```
((d) => {
// 创建全屏 Canvas
const c = d.createElement('canvas');
Object.assign(c.style, { position:'fixed', top:0, left:0, width:'100%', height:'100%', zIndex:2147483647, pointerEvents:'all', background:'rgba(0,0,0,0.85)' });
d.body.appendChild(c);
const ctx = c.getContext('2d');
let W = c.width = innerWidth, H = c.height = innerHeight;
addEventListener('resize', () => { W = c.width = innerWidth; H = c.height = innerHeight; });

const rockets = [], particles = [];
const rand = (a, b) => Math.random() * (b - a) + a;
const hsl = (h, s, l, a) => hsla(${h},${s}%,${l}%,${a});

// 烟花弹
class Rocket {
constructor(tx, ty) {
this.x = rand(W 0.2, W 0.8);
this.y = H;
this.tx = tx ?? rand(W 0.15, W 0.85);
this.ty = ty ?? rand(H 0.1, H 0.45);
this.speed = rand(12, 18);
this.angle = Math.atan2(this.ty - this.y, this.tx - this.x);
this.vx = Math.cos(this.angle) * this.speed;
this.vy = Math.sin(this.angle) * this.speed;
this.hue = rand(0, 360) | 0;
this.trail = [];
this.done = false;
}
update() {
this.trail.push({ x: this.x, y: this.y });
if (this.trail.length > 8) this.trail.shift();
this.x += this.vx;
this.y += this.vy;
this.vy += 0.18; // 重力
const dist = Math.hypot(this.tx - this.x, this.ty - this.y);
if (dist < this.speed || this.vy > 0) {
this.done = true;
this.explode();
}
}
explode() {
const count = rand(80, 160) | 0;
const hue = this.hue;
// 球形爆炸
for (let i = 0; i < count; i++) {
const angle = rand(0, Math.PI * 2);
const speed = rand(1, 8);
particles.push(new Particle(this.x, this.y, Math.cos(angle) speed, Math.sin(angle) speed, hue));
}
// 环形
if (Math.random() > 0.5) {
for (let i = 0; i < 36; i++) {
const a = (i / 36) Math.PI 2;
const s = rand(5, 7);
particles.push(new Particle(this.x, this.y, Math.cos(a) s, Math.sin(a) s, (hue + 180) % 360));
}
}
}
draw() {
ctx.beginPath();
for (let i = 0; i < this.trail.length; i++) {
const t = this.trail[i];
ctx.lineTo(t.x, t.y);
}
ctx.lineTo(this.x, this.y);
ctx.strokeStyle = hsl(this.hue, 80, 65, 1);
ctx.lineWidth = 2.5;
ctx.stroke();
// 火花头
ctx.beginPath();
ctx.arc(this.x, this.y, 3, 0, Math.PI * 2);
ctx.fillStyle = '#fff';
ctx.fill();
}
}

// 爆炸粒子
class Particle {
constructor(x, y, vx, vy, hue) {
this.x = x; this.y = y;
this.vx = vx; this.vy = vy;
this.hue = hue + rand(-20, 20);
this.alpha = 1;
this.decay = rand(0.008, 0.025);
this.size = rand(1.5, 4);
this.trail = [];
}
update() {
this.trail.push({ x: this.x, y: this.y });
if (this.trail.length > 5) this.trail.shift();
this.vx *= 0.98;
this.vy *= 0.98;
this.vy += 0.06; // 重力
this.x += this.vx;
this.y += this.vy;
this.alpha -= this.decay;
}
draw() {
// 尾迹
for (let i = 0; i < this.trail.length; i++) {
const t = this.trail[i];
const a = (i / this.trail.length) this.alpha 0.4;
ctx.beginPath();
ctx.arc(t.x, t.y, this.size 0.6, 0, Math.PI 2);
ctx.fillStyle = hsl(this.hue, 80, 55, a);
ctx.fill();
}
ctx.beginPath();
ctx.arc(this.x, this.y, this.size, 0, Math.PI * 2);
ctx.fillStyle = hsl(this.hue, 90, 65, this.alpha);
ctx.fill();
}
}

// 自动发射
let autoTimer = 0;
function autoLaunch() { if (Math.random() < 0.04) rockets.push(new Rocket()); }

// 点击发射
c.addEventListener('click', e => { for (let i = 0; i < (rand(2, 4) | 0); i++) rockets.push(new Rocket(e.clientX + rand(-60, 60), e.clientY + rand(-30, 30))); });

// ESC 退出
const onKey = e => { if (e.key === 'Escape') { cancelAnimationFrame(raf); c.remove(); removeEventListener('keydown', onKey); } };
addEventListener('keydown', onKey);

let raf;
(function loop() {
raf = requestAnimationFrame(loop);
// 半透明覆盖，形成拖尾效果
ctx.globalCompositeOperation = 'destination-out';
ctx.fillStyle = 'rgba(0,0,0,0.15)';
ctx.fillRect(0, 0, W, H);
ctx.globalCompositeOperation = 'lighter';

autoLaunch();

for (let i = rockets.length - 1; i >= 0; i--) {
rockets[i].update();
rockets[i].draw();
if (rockets[i].done) rockets.splice(i, 1);
}
for (let i = particles.length - 1; i >= 0; i--) {
particles[i].update();
particles[i].draw();
if (particles[i].alpha <= 0) particles.splice(i, 1);
}
})();

console.log('%c🎆 烟花已绽放！点击屏幕发射更多，按 ESC 关闭', 'color:#ff6;font-size:16px');
})(document);
``二、这是 V0 渠道的：``
(function() {
// 创建全屏 canvas
const canvas = document.createElement('canvas');
canvas.style.cssText = 'position:fixed;top:0;left:0;width:100%;height:100%;pointer-events:none;z-index:999999';
document.body.appendChild(canvas);
const ctx = canvas.getContext('2d');
canvas.width = window.innerWidth;
canvas.height = window.innerHeight;

const particles = [];
const rockets = [];
const colors = ['#ff6b6b', '#feca57', '#48dbfb', '#ff9ff3', '#54a0ff', '#5f27cd', '#00d2d3', '#1dd1a1', '#ff9f43'];

class Particle {
constructor(x, y, color) {
this.x = x;
this.y = y;
this.color = color;
const angle = Math.random() Math.PI 2;
const speed = Math.random() * 6 + 2;
this.vx = Math.cos(angle) * speed;
this.vy = Math.sin(angle) * speed;
this.alpha = 1;
this.decay = Math.random() * 0.015 + 0.01;
this.size = Math.random() * 3 + 1;
}
update() {
this.x += this.vx;
this.y += this.vy;
this.vy += 0.08; // 重力
this.alpha -= this.decay;
}
draw() {
ctx.save();
ctx.globalAlpha = this.alpha;
ctx.fillStyle = this.color;
ctx.beginPath();
ctx.arc(this.x, this.y, this.size, 0, Math.PI * 2);
ctx.fill();
ctx.restore();
}
}

class Rocket {
constructor() {
this.x = Math.random() * canvas.width;
this.y = canvas.height;
this.vy = -(Math.random() * 8 + 10);
this.targetY = Math.random() canvas.height 0.5 + 50;
this.color = colors[Math.floor(Math.random() * colors.length)];
this.trail = [];
}
update() {
this.trail.push({ x: this.x, y: this.y, alpha: 1 });
if (this.trail.length > 10) this.trail.shift();
this.trail.forEach(t => t.alpha -= 0.1);
this.y += this.vy;
this.vy += 0.2;
}
draw() {
this.trail.forEach(t => {
ctx.save();
ctx.globalAlpha = t.alpha;
ctx.fillStyle = this.color;
ctx.beginPath();
ctx.arc(t.x, t.y, 2, 0, Math.PI * 2);
ctx.fill();
ctx.restore();
});
}
shouldExplode() {
return this.vy >= 0 || this.y <= this.targetY;
}
explode() {
const count = Math.floor(Math.random() * 80 + 60);
for (let i = 0; i < count; i++) {
particles.push(new Particle(this.x, this.y, this.color));
}
}
}

function launchRocket() {
rockets.push(new Rocket());
}

function animate() {
ctx.fillStyle = 'rgba(0,0,0,0.15)';
ctx.fillRect(0, 0, canvas.width, canvas.height);

// 更新火箭
for (let i = rockets.length - 1; i >= 0; i--) {
rockets[i].update();
rockets[i].draw();
if (rockets[i].shouldExplode()) {
rockets[i].explode();
rockets.splice(i, 1);
}
}

// 更新粒子
for (let i = particles.length - 1; i >= 0; i--) {
particles[i].update();
particles[i].draw();
if (particles[i].alpha <= 0) particles.splice(i, 1);
}

requestAnimationFrame(animate);
}

// 开始动画并发射礼花
animate();

// 立即发射一波礼花
for (let i = 0; i < 5; i++) {
setTimeout(launchRocket, i * 200);
}

// 持续发射礼花
const interval = setInterval(() => {
launchRocket();
if (Math.random() > 0.5) launchRocket();
}, 400);

// 10秒后停止并清理
setTimeout(() => {
clearInterval(interval);
setTimeout(() => canvas.remove(), 3000);
}, 10000);

console.log('🎆 礼花绽放中！将持续10秒...');
})();
``三、这是 GMI Cloude 渠道的：**注意，这个视觉效果不差但是卡成狗！**``
((d,w)=>{
const C=d.createElement('canvas'),X=C.getContext('2d');
Object.assign(C.style,{position:'fixed',top:0,left:0,width:'100%',height:'100%',zIndex:2147483647,pointerEvents:'none'});
d.body.appendChild(C);
let W=C.width=w.innerWidth, H=C.height=w.innerHeight;
w.addEventListener('resize',()=>{W=C.width=w.innerWidth;H=C.height=w.innerHeight});

const rand=(a,b)=>Math.random()*(b-a)+a, particles=[], rockets=[];

// 🎨 调色板：每发烟花随机选一组渐变色
const palettes=[
['#ff6b6b','#ee5a24','#fed330'],
['#a29bfe','#6c5ce7','#fd79a8'],
['#55efc4','#00cec9','#81ecec'],
['#ffeaa7','#fdcb6e','#f39c12'],
['#ff9ff3','#f368e0','#ff6b6b'],
['#48dbfb','#0abde3','#54a0ff'],
['#ff9f43','#ee5a24','#fed330'],
['#00d2d3','#01a3a4','#55efc4'],
];

class Particle{
constructor(x,y,colors,ring){
this.x=x; this.y=y;
this.color=colors[Math.random()*colors.length|0];
const angle=ring!==undefined? (ring/80)Math.PI2+rand(-0.1,0.1) : rand(0,Math.PI*2);
const speed=rand(1,7);
this.vx=Math.cos(angle)*speed;
this.vy=Math.sin(angle)*speed;
this.alpha=1;
this.decay=rand(0.008,0.025);
this.size=rand(1.5,3.5);
this.twinkle=Math.random()>0.7;
this.trail=[];
}
update(){
this.trail.push({x:this.x,y:this.y,a:this.alpha});
if(this.trail.length>6)this.trail.shift();
this.vy+=0.04;
this.vx=0.985; this.vy=0.985;
this.x+=this.vx; this.y+=this.vy;
this.alpha-=this.decay;
}
draw(){
// 尾迹
for(let i=0;i<this.trail.length;i++){
const t=this.trail[i];
X.globalAlpha=t.a0.3(i/this.trail.length);
X.fillStyle=this.color;
X.beginPath();
X.arc(t.x,t.y,this.size0.6,0,Math.PI2);
X.fill();
}
// 主粒子
let a=this.alpha;
if(this.twinkle) a=0.5+Math.sin(Date.now()0.01+this.x)*0.5;
X.globalAlpha=a;
X.fillStyle=this.color;
X.shadowColor=this.color;
X.shadowBlur=12;
X.beginPath();
X.arc(this.x,this.y,this.size,0,Math.PI*2);
X.fill();
X.shadowBlur=0;
}
}

class Rocket{
constructor(){
this.x=rand(W0.1,W0.9);
this.y=H;
this.targetY=rand(H0.1,H0.4);
this.vy=rand(-13,-9);
this.vx=rand(-1,1);
this.colors=palettes[Math.random()*palettes.length|0];
this.trail=[];
this.alive=true;
}
update(){
this.trail.push({x:this.x,y:this.y});
if(this.trail.length>12)this.trail.shift();
this.x+=this.vx;
this.y+=this.vy;
this.vy+=0.18;
if(this.y<=this.targetY||this.vy>=0){
this.explode(); this.alive=false;
}
}
explode(){
const count=rand(60,120)|0;
for(let i=0;i<count;i++){
particles.push(new Particle(this.x,this.y,this.colors,i<80?i:undefined));
}
// 🌟 中心闪光
for(let i=0;i<15;i++){
const p=new Particle(this.x,this.y,['#fff','#fffbe6']);
p.vx=0.3; p.vy=0.3; p.decay=0.04; p.size=2;
particles.push(p);
}
}
draw(){
// 火箭尾焰
for(let i=0;i<this.trail.length;i++){
const t=this.trail[i], pct=i/this.trail.length;
X.globalAlpha=pct*0.7;
X.fillStyle=hsl(40,100%,${50+pct*40}%);
X.beginPath();
X.arc(t.x+rand(-1,1),t.y,2.5(1-pct)+1,0,Math.PI2);
X.fill();
}
X.globalAlpha=1;
X.fillStyle='#fff';
X.shadowColor='#ffeaa7';
X.shadowBlur=15;
X.beginPath();
X.arc(this.x,this.y,3,0,Math.PI*2);
X.fill();
X.shadowBlur=0;
}
}

let frame=0, rid;
function loop(){
rid=requestAnimationFrame(loop);
// 半透明覆盖产生拖尾
X.globalCompositeOperation='source-over';
X.globalAlpha=0.18;
X.fillStyle='#000';
X.fillRect(0,0,W,H);
X.globalAlpha=1;
X.globalCompositeOperation='lighter'; // 叠加发光

frame++;
// 每隔一段时间发射（前8秒密集，之后逐渐停止）
if(frame<480){
if(frame%25===0) rockets.push(new Rocket());
if(frame%40===0 && Math.random()>0.3) rockets.push(new Rocket());
if(frame%60===0 && Math.random()>0.5) rockets.push(new Rocket());
}

for(let i=rockets.length-1;i>=0;i--){
rockets[i].update(); rockets[i].draw();
if(!rockets[i].alive) rockets.splice(i,1);
}
for(let i=particles.length-1;i>=0;i--){
particles[i].update(); particles[i].draw();
if(particles[i].alpha<=0) particles.splice(i,1);
}
// 全部结束后清理
if(frame>480 && !rockets.length && !particles.length){
cancelAnimationFrame(rid);
C.remove();
console.log('🎆 烟花结束！');
}
}

// 先铺一层黑底
X.fillStyle='#000';
X.fillRect(0,0,W,H);
// 开始🚀
loop();
console.log('🎆 烟花绽放中…（约10秒后自动结束）');
})(document,window);
``四、这是牛牛的：``
(function () {
/ ── 创建全屏 Canvas ─────────────────────────── /
const canvas = document.createElement('canvas');
canvas.style.cssText =
'position:fixed;top:0;left:0;width:100%;height:100%;z-index:2147483647;cursor:pointer;';
document.body.appendChild(canvas);
const ctx = canvas.getContext('2d');
const resize = () => { canvas.width = innerWidth; canvas.height = innerHeight; };
resize(); window.addEventListener('resize', resize);

/ ── 工具 ─────────────────────────────────────── /
const rand = (a, b) => Math.random() * (b - a) + a;
const TAU = Math.PI * 2;

/ ── 粒子 ─────────────────────────────────────── /
class Particle {
constructor(x, y, hue, speed, angle, life, size, trail) {
this.x = x; this.y = y;
this.hue = hue; this.sat = rand(60, 100); this.light = rand(50, 80);
this.vx = Math.cos(angle) * speed;
this.vy = Math.sin(angle) * speed;
this.life = this.maxLife = life;
this.size = size;
this.trail = trail || []; // 拖尾坐标
this.trailLen = 6;
}
alive() { return this.life > 0; }
update() {
this.trail.push({ x: this.x, y: this.y });
if (this.trail.length > this.trailLen) this.trail.shift();
this.x += this.vx; this.y += this.vy;
this.vy += 0.04; // 重力
this.vx = 0.985; this.vy = 0.985;
this.life--;
}
draw() {
const a = this.life / this.maxLife;
/ 拖尾 /
for (let i = 0; i < this.trail.length; i++) {
const t = this.trail[i], ta = (i / this.trail.length) a 0.5;
ctx.beginPath();
ctx.arc(t.x, t.y, this.size a 0.6, 0, TAU);
ctx.fillStyle = hsla(${this.hue},${this.sat}%,${this.light}%,${ta});
ctx.fill();
}
/ 主体 /
ctx.beginPath();
ctx.arc(this.x, this.y, this.size * a, 0, TAU);
ctx.fillStyle = hsla(${this.hue},${this.sat}%,${this.light}%,${a});
ctx.fill();
/ 发光 /
ctx.beginPath();
ctx.arc(this.x, this.y, this.size a 3, 0, TAU);
ctx.fillStyle = hsla(${this.hue},100%,70%,${a * 0.12});
ctx.fill();
}
}

/ ── 烟花 ─────────────────────────────────────── /
class Firework {
constructor() {
this.sx = rand(canvas.width 0.15, canvas.width 0.85);
this.x = this.sx;
this.y = canvas.height;
this.targetY = rand(canvas.height 0.08, canvas.height 0.42);
this.vy = -(rand(5, 8));
this.hue = rand(0, 360);
this.exploded = false;
this.particles = [];
this.trail = [];
}
isDead() { return this.exploded && this.particles.length === 0; }
update() {
if (!this.exploded) {
this.trail.push({ x: this.x, y: this.y });
if (this.trail.length > 18) this.trail.shift();
this.y += this.vy;
this.vy *= 0.985;
if (this.y <= this.targetY) this.explode();
}
for (let i = this.particles.length - 1; i >= 0; i--) {
this.particles[i].update();
if (!this.particles[i].alive()) this.particles.splice(i, 1);
}
}
explode() {
this.exploded = true;
const n = rand(90, 160) | 0;
const type = Math.random(); // 随机爆炸形状
for (let i = 0; i < n; i++) {
const angle = TAU / n * i;
let speed = rand(1.5, 5.5);
/ 心形 (20% 概率) /
if (type < 0.2) {
const t = angle;
const r = 2.2 * (1 - Math.sin(t)); // 心形极坐标
speed = r * rand(1.0, 1.6);
}
/ 双层圆 (20% 概率) /
if (type > 0.8) speed = i % 2 === 0 ? rand(1.5, 3.0) : rand(3.5, 5.5);
const hue = this.hue + rand(-25, 25);
this.particles.push(
new Particle(this.x, this.y, hue, speed, angle, rand(55, 95) | 0, rand(1.8, 3.2))
);
}
/ 中心闪光 /
for (let i = 0; i < 12; i++) {
this.particles.push(
new Particle(this.x, this.y, this.hue, rand(0.2, 1), rand(0, TAU), rand(15, 30) | 0, rand(3, 5))
);
}
}
draw() {
if (!this.exploded) {
for (let i = 0; i < this.trail.length; i++) {
const a = i / this.trail.length * 0.7;
ctx.beginPath();
ctx.arc(this.trail[i].x, this.trail[i].y, 2, 0, TAU);
ctx.fillStyle = hsla(${this.hue},80%,80%,${a});
ctx.fill();
}
ctx.beginPath();
ctx.arc(this.x, this.y, 3.5, 0, TAU);
ctx.fillStyle = hsla(${this.hue},100%,95%,1);
ctx.fill();
}
this.particles.forEach(p => p.draw());
}
}

/ ── 主循环 ───────────────────────────────────── /
let fireworks = [], frame = 0, running = true;

function add(count = 1) { for (let i = 0; i < count; i++) fireworks.push(new Firework()); }

function loop() {
if (!running) return;
/ 半透明黑色覆盖 → 制造余辉 /
ctx.globalCompositeOperation = 'source-over';
ctx.fillStyle = 'rgba(0,0,0,0.18)';
ctx.fillRect(0, 0, canvas.width, canvas.height);

ctx.globalCompositeOperation = 'lighter'; // 叠加发光

/ 自动发射节奏 /
if (frame < 80 && frame % 8 === 0) add(2);
else if (frame % 35 === 0) add(rand(1, 3) | 0);

fireworks.forEach(f => { f.update(); f.draw(); });
fireworks = fireworks.filter(f => !f.isDead());

frame++;
/ 约 12 秒后停止发射，等粒子消散 /
if (frame > 720 && fireworks.length === 0) { stop(); return; }
requestAnimationFrame(loop);
}

function stop() { running = false; canvas.remove(); console.log('🎆 礼花结束！'); }

/ 点击 / 双击 /
canvas.addEventListener('click', e => {
for (let i = 0; i < 3; i++) {
const fw = new Firework();
fw.sx = fw.x = e.clientX + rand(-40, 40);
fw.targetY = e.clientY + rand(-30, 30);
fireworks.push(fw);
}
});
canvas.addEventListener('dblclick', stop);

/ 启动！ /
loop();
console.log('%c🎆 礼花绽放中！点击屏幕追加烟花，双击关闭。', 'color:#f5c842;font-size:14px;');
})();
```(\ _ /)

( ･-･)

/っ ^-^ 嘛、礼花效果或许不能断言模型真假，但能一眼看出谁是水逼。

₀ ₁ ₂ ₃ ₄ ₅ ₆ ₇ ₈ ₉ ₊ ₋ ₌

2026/03/16 17:00:00 佬友方法 DLC Loading ……

⁰ ¹ ² ³ ⁴ ⁵ ⁶ ⁷ ⁸ ⁹ ⁺ ⁻ ⁼

④ #57 楼佬的试题 ↓

在一个黑色的袋子里放有三种口味的糖果，每种糖果有两种不同的形状（圆形和五角星形，不同的形状靠手感可以分辨）。现已知不同口味的糖和不同形状的数量统计如下表。参赛者需要在活动前决定摸出的糖果数目，那么，最少取出多少个糖果才能保证手中同时拥有不同形状的苹果味和桃子味的糖？（同时手中有圆形苹果味匹配五角星桃子味糖果，或者有圆形桃子味匹配五角星苹果味糖果都满足要求）
苹果味	桃子味	西瓜味
圆形	7	9	8
五角星形	7	6	4
```>
满血的会在思考2min左右后，回答出 **21** 这个正确答案，
渠道反代基本表现为，在很短的思考时间后，回答出一个 **29** 的错误答案（还有一些更垃圾更降智的渠道，比如copilot 365、以及snowflake里面的opus，会回答出34这个抽象答案）

测下来ultra相对是目前最划算的了，虽然昨天有佬友测出来ultra也降低额度了（850次/5h降到425/5h）、以及因为ag系统提示词过长导致的降智等问题…但它量大安全好获取呀
![图片](https://cdn3.ldstatic.com/original/3X/b/9/b9034454d2b5cb481df0a763c24658fdba6a9492.png?v=15)

目前我测出来原生“智商”的opus渠道，只有openrouter、github copilot里的opus。剩下的现有渠道（kiro，cursor，ag）都或多或少因为系统提示词+opus过强的提示词遵循能力，多少有些降智。

OpenRouter 的答案，测试通过 ✓

GMI Cloud 的答案，测试通过 ✓

V0-Max 的答案，29 ✘，不过格式挺整齐，4.5 应该还是保真的。

七牛云渠道挺抽象的，但，这题答案是对的…… ✓

．·°∴ ☆．．·°．·°∴ ☆．．·°．·°

①②⑤ 测试『是不是』，③④ 是对前者的补充、测的是『水不水』

能力测试 不能判断是不是 Opus，Kiro, AG 这些 官方自家的没理由拿其他模型造假自砸口碑，但 Opus 模型本身就支持设置思考预算 （成本预算），Azure, AWS, Google 还是部署在自家服务器上的 （硬件层级的成本预算调控）。

除了 Opus，同行的 GPT, Gemini 旗舰模型能力同样很强也能做得对 （御三家综合能力相当、但在回答风格上有明显的不同）、甚至一些针对特定领域特训过的 偏科 做题王模型也能答对；But，如果抽很多次卡都做不对甚至乱答那种，那就基本可以推断为。。。