DEV Community: cz

What Is Jev? The 2026 Complete Guide to TypeSafe's System One Model (200x Faster, 400x Cheaper AI Decisions)

cz — Sat, 19 Sep 2026 14:36:28 +0000

🎯 Key Takeaways (TL;DR)

Jev is not a chat model and doesn't generate text: it's the first "System One Model" from TypeSafe AI. You feed it a state (structured data) plus a set of typed questions, and it returns calibrated, structured decisions your software can act on directly.
Official benchmark: two orders of magnitude faster and cheaper — up to 193.6x faster and 444.6x cheaper than comparable LLMs on System One task workflows (~$0.000081 / 0.114s per decision vs $0.01388 / 8.566s for LLMs, per TypeSafe's site).
Three question types: Noul (true/false), Choice (multi-class), and Score (ordinal rating) — every answer ships with calibrated probabilities and a confidence score, so developers can gate "act automatically" vs "escalate to a human" on thresholds.
Available everywhere you already build: Cloudflare Workers AI (model ID typesafe/jev), OpenRouter (typesafe/jev-1.13, $0.042/M input tokens, output free), and LangChain (the langchain-typesafe package). Context window: 32K tokens.
It complements LLMs, it doesn't replace them: the LLM handles open-ended reasoning (System Two), Jev handles high-volume fast structured judgments (System One) — together they form the complete stack.

What Is Jev and Why Doesn't It Generate Text?
What Exactly Is a "System One Model"?
How Does Jev Work?
Performance and Pricing: What Does 200x Faster Mean?
How to Get Started with Jev (Three Paths + Code)
Jev vs Traditional LLMs: Which Should You Use?
What Are the Real-World Use Cases?
Limitations and Caveats
FAQ
Conclusion and Next Steps

What Is Jev and Why Doesn't It Generate Text?

Jev is a structured evaluation model released by TypeSafe AI in September 2026, and the first product in the category the company calls "System One Models." In one sentence: you give it a state and a few questions about that state, and it returns typed answers with probabilities — not prose.

This breaks our usual intuition about "AI models." Traditional LLMs (Claude, GPT, and friends) are autoregressive text generators — they produce natural language token by token, and your application layer then parses, retries, and validates that text into something the software can use. Jev skips text generation entirely:

Input: a state (a plain string or an arbitrarily nested JSON object — a support ticket, an order, an account record) + a set of typed questions
Output: one typed answer per question, each with calibrated probabilities and a confidence score
The trade-off: there's no room for "rambling," "going off-topic," or "hallucinated paragraphs" — because there is no free-form text output at all

TypeSafe markets this as "Zero Hallucinations." The precise meaning is that outputs are always the expected data structure and every decision carries a confidence estimate, so software knows when to act autonomously and when to escalate to a human review. (That's the vendor's framing — see the limitations section before you bet production money on it.)

What Exactly Is a "System One Model"?

The "System 1 / System 2" framing borrows from the dual-process theory in psychology: System 1 is fast, intuitive, automatic; System 2 is slow, deliberate reasoning. TypeSafe uses it to divide labor between AI models:

Dimension	System One model (Jev)	System Two model (traditional LLM)
Output	Typed decisions (data)	Free text (strings)
Latency	~0.1 second	Seconds to tens of seconds
Cost	~$0.000081 per decision	~$0.0138 per decision
Consistency	Fixed structure, with confidence	Wording varies run to run
Good at	Classify, route, score, gatekeep	Open-ended reasoning, writing, planning
Analogy	Intuitive reaction	Deep thinking

TypeSafe's core argument: RLHF tuned LLMs into "chat machines optimized for human preferences," which introduced mode dropping, overconfidence, and reliability problems — which is why every production system still needs a human in the loop. But machine-to-machine communication doesn't need natural language at all. Jev is designed for "machine-native" decision workloads — what the company calls "more like code": reliable, fast, self-consistent, and type-safe.

💡 Pro tip
Don't think of Jev as "a cheaper GPT." It's a judgment node in your pipeline: the LLM understands complex open-ended problems and generates solutions; Jev makes fast, quantifiable, auditable calls at the branching points of the workflow. They are complements.

How Does Jev Work?

Three Question Types

Jev's API has exactly two core concepts: a state (the data to evaluate) and questions (about that data). Questions come in three types:

Question type	Purpose	Returns
Noul	Binary true/false judgment (with criteria)	Probability the statement is true (e.g., 0.95)
Choice	Single-label classification, each option can carry descriptive criteria	Selected option + per-option probabilities + confidence (e.g., billing, 0.8)
Score	Rating against an ordered scale (e.g., 0–2)	Continuous score + distribution + confidence (e.g., 1.04, confidence 0.94)

A realistic example (from Cloudflare's official docs): a support ticket saying "payouts have been failing for 3 days," evaluated against three questions at once —

Noul "Is this urgent?" → 0.95
Choice "Which department should handle it?" → billing, confidence 0.8
Score "Customer frustration 0–2?" → 1.04, confidence 0.94

Batch Questions, Almost No Extra Latency

Multiple questions can be sent against the same state in one call, and Jev evaluates them in parallel. Extra questions barely affect response time — they only cost their token usage. So you can ask "is it urgent? who should own it? how angry is the customer? do they deserve a refund?" all at once with essentially unchanged latency.

The Decision Flow

📊 Jev Decision Workflow

graph TD
    A[Business event: ticket / order / log / agent state] --> B[Build state: text or JSON]
    B --> C[Define questions: Noul / Choice / Score]
    C --> D[Jev parallel evaluation]
    D --> E[Typed answers + confidence]
    E --> F{Confidence >= threshold?}
    F -->|Yes| G[Act automatically: route / escalate / block]
    F -->|No| H[Escalate to human review]
    G --> I[Log decision + probability: auditable]
    H --> I

Training: RLCD

Jev is built on a new architecture and a new sampler, trained with a new algorithm called RLCD (Reinforcement Learning for Calibrated Decisions). Where RLHF optimizes for "human preference," RLCD optimizes for "calibrated decisions" — the probabilities the model reports must genuinely reflect its accuracy. That calibration is exactly what makes confidence-threshold strategies viable in production.

Performance and Pricing: What Does 200x Faster Mean?

TypeSafe's published benchmark (System One task workflows):

Metric	TypeSafe (Jev)	Traditional LLM	Gap
Cost per decision	$0.000081	$0.013880	444.6x
Latency per decision	0.114s	8.566s	193.6x
Input token price	$42 / 1B tokens	—	Claimed 238x cheaper than Claude Fable 5.1

The LangChain blog quotes a "up to 200x faster, 400x cheaper" figure for integrated scenarios — consistent with the official numbers (one is the vendor's peak claim, the other is the in-the-wild framing).

Market data supports the magnitude: jev-1.13 went live on OpenRouter on September 18, 2026, priced at $0.042 per million input tokens and $0 per million output tokens (the output is a tiny typed JSON, so it's simply not billed), and it processed over 161 billion tokens in its first days on the platform (source: OpenRouter model page).

💡 Pro tip
Do the arithmetic: $42 per billion input tokens ≈ roughly 240 single-question decisions per penny. For high-frequency scenarios where "every email, every ticket, every tool call gets a judgment," this is the first cost structure that makes full-coverage judgment economically viable — which is why this space used to be handled with keyword rules or random sampling.

How to Get Started with Jev (Three Paths + Code)

Path 1: Cloudflare Workers AI (Model ID: `typesafe/jev`)

Jev is available as a third-party model on Cloudflare Workers AI with a 32K token context window, callable via the Worker binding or the REST API. The state can be a plain string or nested JSON (questions reference fields with backticks, e.g. ticket.message\):

// Inside a Cloudflare Worker
const result = await env.AI.run("@cf/typesafe/jev", {
  state: {
    ticket: { message: "Stripe webhook has been failing for 3 days", channel: "email" },
    order: { total: 499.0, status: "paid" },
    policy: "Duplicate charges with service unavailable for 24+ hours qualify for a full refund"
  },
  questions: {
    is_urgent: {
      type: "noul",
      question: "Does this ticket need immediate escalation?"
    },
    department: {
      type: "choice",
      question: "Which department should handle this?",
      choices: { billing: "Billing and payment issues", technical: "Technical failures", account: "Account issues" }
    },
    refund_warranted: {
      type: "noul",
      question: "Does the refund policy support a refund for this order?"
    }
  }
});

// Every answer comes with probability and confidence
console.log(result.is_urgent);          // { value: true, probability: 0.95, ... }
console.log(result.department);         // { value: "billing", confidence: 0.8, ... }

The official docs provide downloadable input/output JSON schemas, and responses include per-question answers plus token usage.

Path 2: OpenRouter (Model ID: `typesafe/jev-1.13`)

If you already route models through OpenRouter, just point your model ID at typesafe/jev-1.13. There's also typesafe/jev-latest, an alias that always resolves to the newest Jev release (currently jev-1.13.0).

Path 3: LangChain (the `langchain-typesafe` package)

The official LangChain blog post "Building a Harness with Jev" demonstrates three integrations:

1. Basic classifier — TypeSafeClassifier takes a state (text, structured data, or LangChain messages) plus questions:

from langchain_typesafe import TypeSafeClassifier, Noul

classifier = TypeSafeClassifier()
response = classifier.invoke(
    state="User reports their Stripe integration is completely down, affecting live payments",
    questions={"urgent": Noul(question="Does this need immediate escalation?")}
)
print(response.nouls["urgent"].noul)   # 0.999 — usable for auto-prioritization

2. Model routing — ModelRouterMiddleware lets Jev choose between a "fast" and a "powerful" model, assigning each request to the cheapest model capable of handling it.

3. Tool-call guardrails (Auto Mode) — AutoModeMiddleware screens risky tool calls (like bash) with Jev before they execute and blocks the dangerous ones. The pattern is inspired by the guardrails in coding harnesses like Claude, Codex, and Cursor — and it's the core play in "building a harness with Jev": use the System One model to insure the System Two model.

✅ Best practice
All three question types support (and deserve) explicit criteria. Don't just ask "is this urgent?" — define what "urgent" means: "affects production, has persisted over 24 hours, or involves money." The more precise your criteria, the more trustworthy the probabilities.

Jev vs Traditional LLMs: Which Should You Use?

Dimension	Jev (System One)	Traditional LLM (System Two)
Output format	Typed decision + probability	Natural language text
Hallucination risk	No free text to drift (vendor claims "zero hallucinations")	Present; requires parsing and validation
Latency	~0.1s	Seconds to minutes
Cost per call	~$0.00008	~$0.014
Open-ended reasoning / generation	Not supported	Core capability
Explainability	Probabilities and distributions, easy to audit	Requires a separate eval framework
Typical role	Routing, triage, scoring, gatekeeping	Conversation, planning, content generation

One-line decision rule: if the answer can be enumerated from a finite set of options, use Jev; if the answer has to be thought up, use an LLM.

What Are the Real-World Use Cases?

From the official docs and community practice (LangChain blog, Cloudflare docs):

Ticket triage and routing: evaluate urgency, owning department, and frustration score in parallel for every ticket, in milliseconds, with full coverage instead of sampling. In one Cloudflare docs example, a login issue routed to the account department with 1.0 confidence.
Agent tool-call guardrails: in coding harnesses, screen high-risk tools like bash before execution and block or escalate when risk is high.
Model routing: split traffic between fast and powerful models by task difficulty to cut overall inference cost.
Refund and compliance review: put the ticket, the order, and the refund policy in one state; the model judges "a refund was requested (0.99)" and "the policy supports it (0.98)."
Account risk scoring: score account activity (1.84 in the docs example, leaning "High risk") with a 0.81 probability recommendation to escalate.
High-frequency lightweight agents: community examples include Browserbase-powered browser agents making decisions for "fractions of a cent," a live trading agent, and large-scale email triage.

Limitations and Caveats

⚠️ Warning
Keep these in mind when evaluating:

It only answers what you ask: Jev does no open-ended reasoning. If the judgment criteria themselves require understanding complex context or generating new information, it's the wrong tool.
"Zero hallucinations" is a vendor claim: structured output eliminates textual drift, but probability judgments can still be wrong. The right posture is not blind trust — it's confidence thresholds with human review as the backstop. Notably, the FAQ items on TypeSafe's site covering accuracy ceilings, failure modes, and whether prices are subsidized remain collapsed and unanswered; benchmark methodology details are still thin.
32K context window: the state can't be arbitrarily large; chunk or summarize long content first.
A brand-new category, early ecosystem: Jev is in early access (console.typesafe.ai). Validate calibration on your own data before production — for example, regression-test the probabilities against historical tickets.

🤔 Frequently Asked Questions

Q: Will Jev replace LLMs?

A: No. Jev doesn't generate text and can't hold conversations, write, or reason openly. Its role is to take over the "judgment" segments of an LLM stack — routing, classification, scoring, approval — so the LLM can focus on the "thinking." LangChain's blog explicitly frames it as a complement to LLMs, not a replacement.

Q: What does "Noul" mean?

A: Noul is a TypeSafe-coined question type for binary true/false evaluation: you provide a statement and its criteria, and Jev returns the probability the statement is true (e.g., 0.95). It sits alongside Choice (multi-class) and Score (ordinal rating) as one of Jev's three question types.

Q: How much does Jev cost?

A: On OpenRouter, typesafe/jev-1.13 is priced at $0.042 per million input tokens (i.e., $42 per billion) with $0 output pricing. TypeSafe's site claims that input price is about 238x lower than Claude Fable 5.1. Note that real "per decision" cost depends on your state length; the official benchmark puts it around $0.000081 per decision.

Q: Where can I use Jev?

A: Four entry points today: Cloudflare Workers AI (typesafe/jev), OpenRouter (typesafe/jev-1.13 or typesafe/jev-latest), TypeSafe's own console at console.typesafe.ai (early access), and the LangChain ecosystem via the langchain-typesafe package (which can sit on top of any of the above).

Q: Is Jev really hallucination-free?

A: The more precise statement is "no text hallucinations" — Jev never generates free-form text, so there's nothing to fabricate paragraphs with. But its probability judgments can still be wrong. In production, pair it with confidence thresholds: auto-execute at high confidence, route to humans at low confidence.

Q: What kind of project should adopt Jev?

A: Three signals: ① you have high-volume, repetitive classification or triage decisions (tickets, emails, moderation, logs); ② you're currently doing those with an LLM and cost or latency can't keep up; ③ your agent pipeline needs cheap gatekeeping (tool-call approval, model routing). Any one of these makes it worth a pilot.

Conclusion and Next Steps

Jev represents a direction worth taking seriously: separating "judgment" from text generation and turning it into a typed, confidence-bearing primitive that software can consume directly. A 193x speed gap and a 444x cost gap aren't "a slightly faster LLM" — they're what makes a "judge everything, in real time, every time" architecture economically viable for the first time.

Recommended next steps:

Validate calibration on real data first: take 100–500 historical tickets or cases, compare Jev's probabilities against human conclusions, and check whether the probabilities mean what they claim — this determines how low you can set your thresholds.
Start with one low-risk scenario: email triage or ticket routing is the ideal entry point (mistakes have a human safety net, and the payoff is immediate).
Then add agent guardrails: if your agents run bash, send emails, or touch databases, use the Auto Mode pattern to give them a System One gatekeeper.

References

TypeSafe: System One Models & Jev announcement — https://typesafe.ai
Cloudflare Workers AI docs: Jev model page — https://developers.cloudflare.com/ai/models/typesafe/jev/
OpenRouter model page: jev-1.13 — https://openrouter.ai/typesafe/jev-1.13
LangChain blog: Building a Harness with Jev — https://www.langchain.com/blog/building-a-harness-with-jev

Antique Scanner: How to Identify & Value Antiques by Photo (2026 Complete Guide)

cz — Sat, 19 Sep 2026 02:00:08 +0000

🎯 Key Takeaways (TL;DR)

Antique Scanner (antiquescanner.org) is an AI research tool that identifies antiques from photos — it reads maker's marks, hallmarks, materials, construction, and wear, then estimates age, origin, and market value.
Every finding carries an honest confidence label — Identified, Likely, Possible, or Uncertain — with the evidence shown, so you know exactly how much to trust it. No guessing presented as fact.
It's fast, cheap, and low-commitment: your first scan is free, a Full Antique Report costs a one-time $3.98 (no subscription), and most scans return in under two minutes.
Best for: collectors, thrifters and resellers, and anyone handling inherited or estate items who needs a research starting point before buying, selling, or paying for a professional appraisal.

What Is an Antique Scanner?
What Can You Scan?
How Does Antique Scanner Work?
What's Inside an Antique Scanner Report?
Antique Scanner vs. Google Lens vs. Traditional Appraisal
How to Photograph Your Antique for the Best Results
Who Should Use an Antique Identifier?
Pricing: What Does a Scan Cost?
How Accurate Is It? Honest Limits
Frequently Asked Questions (FAQ)
Conclusion & Next Steps

What Is an Antique Scanner?

An antique scanner is a web-based AI tool that identifies old objects from photographs. Instead of matching images by visual similarity (the way a reverse image search does), Antique Scanner examines the details that appraisers actually trust — maker's marks, hallmarks, materials, construction techniques, and wear patterns — and produces a structured research report telling you:

What the item probably is (maker, origin, materials, construction)
When it was likely made (age estimate, often to the decade)
What it may be worth (a three-tier value range, not one invented number)

The companion Antique Identifier page runs the same engine with a sharper focus on the identification step: naming that mystery item before you think about price.

The key idea: an antique never has one single "correct" price, and photo identification is never guaranteed. Antique Scanner is built to say what the evidence supports — and to tell you plainly when it doesn't support more. That honesty is the product's core differentiator in a market full of tools that confidently guess.

💡 Pro Tip

Marks are the strongest signal. A single sharp photo of the base or maker's mark can lift a finding from "Likely" to genuinely "Identified" — often more valuable than five photos of the pretty side.

What Can You Scan?

The antique scanner works on porcelain, silver, furniture, watches, pottery marks — if it's old, it can help you read it. Real examples from the site:

Category	Example result from a scan
Porcelain vase	Hand-painted baluster vase — likely early 20th century, read from the base mark and paste. Market range $120–200.
Vintage watch	Mechanical dress watch, probable 1950s movement; serial range and dial fonts agreed. Redial flags: none.
Silver spoon	Sterling pattern identified from hallmarks — standard, maker, and date letter all read; date letter confirmed the assay year.
Antique chair	Ladder-back country chair with hand-cut joinery, 19th century; condition wear priced into the estimate.
Pottery mark	Impressed maker's mark matched to a pottery — the finding climbed from Likely to Identified on the mark alone.

Beyond these, the tool handles glass, clocks, jewelry, paintings, books, tools, and most decorative objects — plus vintage and collectible items. It reads British hallmarks, continental factory marks, American art pottery, Asian ceramics, and more, wherever the photos carry readable form, materials, or marks. Reports are written in English whatever the item's origin.

The site also offers category-specific identifier pages with sharper guidance per material:

How Does Antique Scanner Work?

From photo to report in three steps:

Upload 1–5 photos. Include a full side profile, the base, and any marks or signatures for the best results. Phone cameras are fine.
AI analyzes the details. The engine examines form, materials, construction, marks, and wear, then estimates age and origin.
Get your value report. A structured report with identification, confidence, evidence, and value ranges — saved to your private history.

graph TD
A[Upload 1–5 photos<br/>profile · base · marks · damage] --> B[AI reads marks, materials,<br/>construction, form & wear]
B --> C[Identification with<br/>confidence label]
C --> D[Three-tier value estimate<br/>quick sale · market · dealer]
D --> E[Report saved to history<br/>+ reshoot suggestions]

Most scans return in under two minutes once they run. Free scans sit in a short queue first; paid scans start instantly on a stronger model.

What's Inside an Antique Scanner Report?

Each report is a structured document with evidence, confidence levels, and honest uncertainties — not a paragraph of guesswork:

Report section	What you get
Maker & mark analysis	Reading of maker's marks, hallmarks, and signatures — the details appraisers trust most
Three-tier value estimate	Quick sale, market, and dealer prices, because an antique never has one "correct" price
Confidence & evidence	Findings labeled Identified, Likely, Possible, or Uncertain, with evidence and open questions shown
Next-photos guidance	When a finding stalls, the report names the exact reshoot that would firm it up
Reproduction flags	Modern construction, inconsistent wear, wrong materials, or a mark style that postdates the piece — stated plainly under uncertainties

The three-tier value estimate deserves explanation, because it mirrors how antiques actually trade:

Tier	What it means
Quick sale	What you'd get selling fast — to a dealer, at auction without reserve, or on a short timeline
Market range	A realistic private-sale or well-marketed auction outcome
Dealer price	What a retail dealer would list it at — the price a buyer pays for the dealer's curation and guarantee

✅ Best Practice

Scan one item at a time so marks and materials don't blend together. For sets like flatware or plates, scan the best-marked piece first — the identification usually covers the pattern, and value then scales by count.

Antique Scanner vs. Google Lens vs. Traditional Appraisal

	Antique Scanner	Google Lens / reverse image search	Professional appraiser
What it does	Reads marks, materials & construction; explains reasoning; estimates value ranges	Finds images that look similar	Hands-on examination, certified documentation
Handles items unlike anything online	✅ Yes — evidence-based, not similarity-based	❌ Weak — needs visual matches	✅ Yes
Value estimate	✅ Three-tier range	❌ No	✅ Formal, certified
Confidence transparency	✅ Every finding labeled with evidence	❌ No reasoning shown	✅ Expert judgment
Cost	First scan free; $3.98 per report after	Free	Typically $50–$150+ per hour
Speed	Under ~2 minutes	Seconds	Days to weeks
Best for	Research before decisions, mystery items, shelf finds	Orienting on well-documented items	Insurance, estate, tax, high-value items

The honest framing: an AI report is a research estimate, not a certified appraisal. For insurance, estate, or tax purposes — or whenever an item may be worth more than $1,000 — use a professional appraiser. The report helps you decide whether that step is worth the fee.

How to Photograph Your Antique for the Best Results

Photo quality decides identification quality. The tool accepts up to 5 photos per scan (JPG / PNG / WEBP), and these four shots cover nearly every item:

Photo	Why it matters
1. Full side profile	Establishes form and silhouette — period fashion leaves fingerprints in shape
2. Bottom / base	Where marks live; also reveals construction and wear honest to age
3. Maker's mark, hallmark, or signature	The strongest single signal — can move a finding from Likely to Identified
4. Close-up of damage or restoration	Condition gets priced into the estimate; hidden repairs get flagged

⚠️ Note

Photograph worn punches and faint impressed marks in raking light (light from a low, sharp angle) so the marks cast small shadows. That one photo often settles the whole identification — and it's exactly what the pottery and silver identifier pages ask for first.

If evidence runs short, the report's next-photos section tells you the exact angle to reshoot rather than leaving you guessing.

Who Should Use an Antique Identifier?

Built for anyone who has ever held an old object and wondered:

Collectors — research an unfamiliar piece before you buy, sell, or insure it.
Thrifters & resellers — check what a shelf find might be worth before you pass it up — or before you pay too much for it.
Estate & family — understand inherited items before dividing, selling, or keeping them.

Three typical moments to reach for the Antique Identifier:

Mystery inherited items — put a name to the pieces in a relative's attic.
Before you buy — check a dealer's or auction's attribution against what the object itself shows.
After the flea market — identify a shelf find the same afternoon you carried it home.

No antiques knowledge is required: the photo tips cover everything, and the report explains its terms as it goes.

Pricing: What Does a Scan Cost?

Simple, one-time pricing — no subscription:

Item	Price
First scan	Free (new accounts get credits for one full research report)
Full Antique Report	$3.98 — one-time payment, no subscription
Credit expiry	Never — credits don't expire
Failed scans	Refunded automatically

For heavier use, see the site's pricing page and the Antique Value Checker page, which focuses on the valuation workflow.

Privacy is equally straightforward: photos are stored privately and never published. The analysis model receives short-lived, expiring links (typically 15 minutes), and you can delete your account and data at any time. Reports stay in your private history until you remove them.

How Accurate Is It? Honest Limits

Every finding carries an honest confidence label together with the evidence behind it and any open questions. Key limits to understand before you rely on a report:

Visual similarity is never reported as a confirmed identification. A lookalike is a lead, not an answer.
Paintings get partial treatment. The tool reads signatures, labels, and obvious style attributes, but attributing art to an artist needs an expert's eye and provenance. Treat painting results as orientation — a period, school, and condition read. (A "school of" finding means the piece was made in the manner and era of a maker, without direct evidence of that maker's hand.)
No photo identification is guaranteed — and any tool that promises one is overselling.
Reproductions get flagged, not ignored. Modern construction, inconsistent wear, wrong materials for the claimed period, or a mark style that postdates the piece are stated plainly under uncertainties.

⚠️ Note

For high-value decisions, treat the report as a research lead and confirm with a professional before committing money. Antique Scanner reports are AI research estimates, not certified appraisals.

🤔 Frequently Asked Questions (FAQ) {#faq}

Q: How is Antique Scanner different from Google Lens?

A: Google Lens finds images that look similar, which helps when you already know roughly what the item is. Antique Scanner goes further: it reads marks, materials, and construction, explains its reasoning, labels its confidence, and estimates value ranges for the item you actually photographed — including pieces that look like nothing in the search results.

Q: How accurate is the identification?

A: Every finding carries a confidence label — Identified, Likely, Possible, or Uncertain — with the evidence and open questions shown. Photos of marks and the base improve accuracy the most. When a finding stalls, the report names the exact reshoot that firms it up.

Q: Can it read pottery marks and silver hallmarks?

A: Yes — marks are the strongest signal the tool reads. Photograph the mark close-up in raking light so worn punches cast small shadows; that one photo often settles the whole identification. The pottery identifier and silver identifier pages carry the same guidance.

Q: Is this a real appraisal?

A: No. Reports are AI research estimates, not certified appraisals. For insurance, estate, or tax purposes — or whenever an item may be worth more than $1,000 — use a professional appraiser. The report helps you decide whether that step is worth the fee.

Q: Can the antique identifier tell if my item is a reproduction?

A: It flags the signs — modern construction, inconsistent wear, wrong materials for the claimed period, or a mark style that postdates the piece. Concerns are stated plainly under uncertainties rather than ignored.

Q: How many photos should I upload?

A: Up to five. Start with a full side profile, then add the bottom or base, any maker's mark or hallmark, and close-ups of damage or restoration. The base and mark shots usually matter most; five slots cover nearly every item.

Q: What does a scan cost?

A: Your first scan is free. After that, a Full Antique Report is $3.98 — one-time payment, no subscription. Credits never expire, and failed scans are refunded automatically.

Q: How long does an identification take?

A: Most scans return in under two minutes once they run. Free scans sit in a short queue first; paid scans start instantly on a stronger model.

Q: What happens to my photos?

A: They're stored privately and never published. The analysis model receives short-lived, expiring links — typically 15 minutes — and you can delete your account and data at any time.

Q: Does it work for items from any country?

A: Yes. The scanner reads British hallmarks, continental factory marks, American art pottery, Asian ceramics, and more — wherever the photos carry readable form, materials, or marks. Reports are written in English whatever the item's origin.

Q: Can one scan cover a set of items?

A: No — scan one item at a time so marks and materials don't blend together. For sets like flatware or plates, scan the best-marked piece first: the identification usually covers the pattern, and value scales by count.

Conclusion & Next Steps {#conclusion}

If you're holding an old object and wondering what it is and what it's worth, Antique Scanner is the most honest first step available online: it reads the marks, materials, and wear in your photos; labels every finding with confidence and evidence; and gives you a three-tier value range instead of a single invented number — with your first scan free and full reports at a one-time $3.98.

Recommended next steps:

Start with the Antique Identifier to name a mystery item, or the homepage scanner for the full identify-and-value workflow.
Photograph deliberately: full profile, base, marks, damage — in raking light for worn punches.
Let the report's confidence labels guide you: act on Identified findings, keep researching Possible ones with the suggested reshoots.
Escalate when it matters: for insurance, estate, tax, or items possibly worth over $1,000, take the report to a professional appraiser — it makes that conversation faster and cheaper.

Related resources:

Antique Scanner — homepage tool
Antique Identifier · Antique Value Checker · Identify Antiques by Photo · Antique Appraisal Online
Category pages: pottery · porcelain · silver · furniture · glass · watches · vases · jewelry

Disclaimer: This article is based on publicly available content from antiquescanner.org, last verified on September 19, 2026. Prices and features are subject to the live site. AI identification results are research estimates and do not constitute a certified appraisal.

Originally published at a2aprotocol.ai

AI 80s Photo Generator (2026): Turn Any Selfie into a 1985 Photo

cz — Wed, 09 Sep 2026 14:41:46 +0000

The "see yourself in the 80s" trend is one of the biggest AI photo phenomena since the AI yearbook: you upload one selfie, and a few seconds later you're staring at what looks like a real photograph of you from 1985 — big hair, statement shoulders, direct flash, analog grain, and that unmistakable red-orange date stamp in the corner. This guide explains how an 80s Photo Generator works, gives you the exact 80s Photo Prompt you can paste into ChatGPT today, and shows the one-click way to get the same result without writing a single prompt — plus 10 real before/after examples so you know exactly what to expect.

🎯 Key Takeaways (TL;DR)

What it is: An AI 80s Photo Generator turns a modern selfie into a convincing 1985 photograph while preserving your face, skin tone, and age — only your hair, outfit, accessories, and surroundings change.
Two ways to do it: Paste our copy-ready 80s Photo Prompt into ChatGPT (GPT-Image) with your photo, or use the 80s Photo Generator on ImageLayered where the prompt is already locked in for you.
Cost & speed: About 1 minute per photo. On ImageLayered it costs 3 credits (≈ $0.15), refunded automatically if generation fails.
Best input: One clear, well-lit photo of one person, face toward the camera, JPG/PNG/WebP up to 10MB.

What Is an AI 80s Photo Generator?
What Is an 80s Photo Prompt?
The 80s Photo Prompt (Copy and Paste)
Method 1: How to Use the 80s Photo Prompt in ChatGPT
Method 2 (Simpler): The One-Click 80s Photo Generator
80s Photo Generator vs ChatGPT: Which Should You Use?
10 Real Before/After Examples
Tips for the Best Result
How Much Does an 80s Photo Cost?
Frequently Asked Questions

What Is an AI 80s Photo Generator?

An AI 80s Photo Generator is a tool that transforms a photo taken today into a photograph that looks like it was shot around 1985. It belongs to the same family as the viral "glorious 80s trend" and the ChatGPT 80s photo trend that flooded Instagram and X: identity-preserving image models got good enough to keep you recognizable while completely restyling everything around your face.

A good 80s Photo Generator changes exactly two categories of things:

What changes	What stays the same
Hairstyle (period-accurate silhouettes)	Facial features
Clothing, accessories, layers	Skin tone
Surroundings and props	Age
Film treatment: analog grain, faded color, direct flash, softness	Overall identity — it's still unmistakably you
Finishing touch: red-orange 1985 date stamp

That last row matters more than people expect. The date stamp, the grain, and the slightly blown-out flash look are the details that make the result read as a photograph from the era rather than a modern photo with a retro filter slapped on. This is also where dedicated 80s photo filters fall short — a filter recolors your photo; a generator rebuilds it.

💡 Pro tip
The phrase to search for is "80s Photo Generator" or "what would I look like in the 80s." Both lead to the same class of tool — the difference is entirely in how well the underlying prompt preserves identity and era accuracy.

What Is an 80s Photo Prompt?

An 80s Photo Prompt is the text instruction you give an AI image model to produce the 1985 look. It's the difference between "make this photo 80s style" (results: random neon grid, synthwave sun, your face half-melted) and a genuinely convincing 1985 photo.

Every effective 80s Photo Prompt does four jobs:

Identity lock — tells the model to preserve your facial features, skin tone, age, and recognizable appearance before it restyles anything. Without this, you get a generic 80s stranger.
Era styling — directs the model to hair, clothing, accessories, and surroundings with specific 1985 vocabulary: expressive silhouettes, statement accessories, layered details, distinctive colors and textures.
Film realism — requests analog grain, faded color, direct flash, and subtle softness, so the output reads as an analog photograph.
Negative constraints — forbids modern objects and text, and adds the period-accurate red-orange date stamp that anchors the photo in time.

The 80s Photo Prompt (Copy and Paste)

Here is the exact prompt used by the ImageLayered 80s Photo Generator. It works in ChatGPT (GPT-Image), and you can paste it anywhere that accepts image prompts:

Using my uploaded photo, show me what I would have looked like around 1985. Preserve my identity, facial features, skin tone, age, and recognizable appearance. Reimagine my hair, clothing, accessories, and surroundings with bold, unmistakably mid-1980s styling—expressive silhouettes, statement accessories, layered details, distinctive colors, and textures. Make it feel like a genuine 1985 photograph with analog grain, faded color, direct flash, and subtle softness. Add a period-accurate 1980s red-orange date stamp in the lower corner. No modern objects or text.

Why this 80s Photo Prompt works, line by line:

Prompt segment	What it does
"show me what I would have looked like around 1985"	Sets the era target explicitly — the model anchors styling to mid-80s, not a vague "retro" look
"Preserve my identity, facial features, skin tone, age"	The identity lock. This is the single most important sentence — it's what keeps the result you
"bold, unmistakably mid-1980s styling"	Pushes the model away from safe, generic outfits toward era-defining silhouettes and accessories
"analog grain, faded color, direct flash, subtle softness"	The four ingredients of an authentic point-and-shoot film photo
"period-accurate 1980s red-orange date stamp in the lower corner"	The timestamp detail that instantly sells the photo as real
"No modern objects or text"	Negative constraint — stops smartphones, modern logos, and added captions from leaking in

Method 1: How to Use the 80s Photo Prompt in ChatGPT

If you already have a ChatGPT subscription with image generation, you can run the 80s Photo Prompt there right now:

Open ChatGPT and start a new conversation (GPT-4o or newer with image generation enabled).
Upload your photo — a clear selfie or portrait works best (see tips).
Paste the 80s Photo Prompt from the section above, exactly as written.
Wait for generation — usually 30–60 seconds.
Review the result. If your face drifted, regenerate and make sure your photo is well-lit and unobstructed.

⚠️ Note
ChatGPT results vary run to run, and free-tier limits can cap how many times you can regenerate. If your first output doesn't preserve your identity well, refining the prompt helps less than uploading a better source photo.

Method 2 (Simpler): The One-Click 80s Photo Generator

The 80s Photo Generator on ImageLayered runs the same class of identity-preserving model with the tuned 1985 prompt above already baked in. No prompt writing, no regenerating to chase a good result:

Upload your photo — drag and drop a JPG, PNG, or WebP up to 10MB.
Click "Generate My 80s Photo." The 1985 look is locked in by default.
Download your photo — a high-quality JPEG, ready in about a minute. Save it right away: generations aren't stored on your account, and download links expire.

💡 Pro tip
Want to use the engine for a different decade or style? The generator has an Advanced option where you can edit the 80s Photo Prompt directly — for example, shift the styling and date stamp to the 90s or Y2K.

80s Photo Generator vs ChatGPT: Which Should You Use?

	80s Photo Generator (ImageLayered)	ChatGPT with the prompt
Setup	None — prompt pre-configured	Paste the 80s Photo Prompt manually
Best for	Everyone, especially first-timers	Existing ChatGPT subscribers
Identity consistency	Tuned prompt, tuned pipeline	Varies between runs
Cost	3 credits ≈ $0.15 per photo, refunded on failure	Included in ChatGPT plan, subject to usage limits
Speed	~1 minute	~30–60 seconds
Editing the style	Advanced prompt editor built in	Edit the prompt text yourself
Photo storage	Not stored; download links expire	Stays in your chat history

Our take: if you just want your 1985 photo with zero friction, use the 80s Photo Generator. If you're already paying for ChatGPT and enjoy tinkering with prompts, running the 80s Photo Prompt there is a fine free-feeling alternative — just expect a bit more trial and error.

10 Real Before/After Examples

We prepared 10 before/after pairs so you can see the identity preservation and era styling for yourself. Each pair shows the original photo (left/before) next to its AI-generated 1985 version (right/after):

Original photo (before)	1985 photo (after)

Two things to notice across the gallery:

The face never changes. Different skin tones, ages, and face shapes — every "after" is recognizably the same person as the "before."
The styling always commits. Volume-heavy hair, layered outfits, statement accessories, direct-flash falloff, and the red-orange date stamp. Nothing half-hearted.

✅ Best practice
Publishing this on your own site? Keep the before/after pairs side by side with descriptive alt text (e.g., "original selfie next to AI-generated 1985 photo, example 3") — before/after galleries are exactly what image search rewards for 80s photo queries.

Tips for the Best Result

Whichever method you choose, the source photo drives the outcome:

One person per photo. Group photos confuse identity locking — crop to a single subject.
Face the camera, eyes visible. Sunglasses, hands, or heavy shadows over the face degrade preservation.
Good light beats good everything else. A well-lit phone selfie outperforms a dark studio portrait.
Higher resolution helps but isn't required. Anything clear up to 10MB works.
Don't pre-filter. Skip the retro filters before uploading — the 80s Photo Prompt applies the film treatment itself; stacking filters compounds artifacts.

⚠️ Note
Treat the output as a fun portrait, not a historical record. Like all generative AI, styling details (fabric patterns, background objects) are imagined and may not be period-perfect.

How Much Does an 80s Photo Cost?

On the ImageLayered 80s Photo Generator, each generation costs 3 credits (≈ $0.15). Credits work across every ImageLayered tool, and if a generation fails or times out, your credits are refunded automatically — you only pay for photos you actually receive.

Compare that to the alternatives: a vintage-style photoshoot runs into the hundreds, and most "80s photo filter" apps either watermark the result or hide the download behind a subscription.

🤔 Frequently Asked Questions

Q: What is an 80s Photo Generator?

A: An 80s Photo Generator is an AI tool that transforms a modern photo of you into a convincing 1985 photograph. It preserves your identity — facial features, skin tone, age — while restyling your hair, clothing, accessories, and surroundings with mid-1980s fashion, then finishes the image with analog grain, faded colors, direct flash, and a red-orange date stamp.

Q: What is an 80s Photo Prompt?

A: An 80s Photo Prompt is the text instruction that tells an AI image model to produce the 1985 look. A complete one includes four parts: an identity lock (preserve face, skin tone, age), era styling directions (hair, clothing, accessories), film realism cues (analog grain, faded color, direct flash), and negative constraints (no modern objects or text). The full prompt used by the ImageLayered generator is in this section.

Q: Is this the same as the ChatGPT 80s photo trend?

A: Same idea, same model class. The viral trend runs OpenAI's GPT-Image model with a reference photo to keep your identity; the ImageLayered 80s Photo Generator uses the same approach with a carefully tuned 1985 prompt — the difference is you don't have to write or paste the 80s Photo Prompt yourself.

Q: Does the 80s Photo Generator keep my face?

A: Yes. Identity preservation is built into the prompt itself: facial features, skin tone, age, and overall recognizable appearance stay yours. Only hair, clothing, accessories, surroundings, and the film treatment change.

Q: Can I use the 80s Photo Prompt for free?

A: If you have a ChatGPT plan that includes image generation, you can paste the 80s Photo Prompt there at no extra cost, subject to ChatGPT's usage limits. The ImageLayered generator costs 3 credits (≈ $0.15) per photo, with automatic refunds on failure.

Q: What photo should I upload?

A: A clear, well-lit photo of one person facing the camera, with the face unobstructed. Selfies, portraits, and casual snapshots all work. JPG, PNG, and WebP up to 10MB are supported.

Q: Are my photos stored?

A: No. On the ImageLayered generator there's no gallery and no history — your upload is used to generate the photo, and the result is delivered straight to you. Download it promptly, because links expire.

Q: Can I generate other decades, like the 90s or Y2K?

A: Yes. The default is locked to 1985, but the Advanced option lets you edit the 80s Photo Prompt — change the era, styling, and date stamp to create a different decade's look with the same engine.

Conclusion and Recommendations

The 80s photo trend is equal parts nostalgia and novelty — and it's never been easier to join. You have two solid paths:

Fastest: Open the 80s Photo Generator, upload a selfie, click generate, download your 1985 photo for about $0.15.
Hands-on: Copy the 80s Photo Prompt above into ChatGPT with your photo and tinker with the styling yourself.

Either way, the formula is the same: protect the identity, commit to the era styling, and finish with the film details — grain, faded color, direct flash, and that red-orange date stamp. Now go find out what you would have looked like in 1985.

Originally published at: AI 80s Photo Generator (2026): Turn Any Selfie into a 1985 Photo

Meta Glasses Converter – Official Website, What It Is & How to Use

cz — Thu, 03 Sep 2026 12:25:50 +0000

Instagram has a small party trick that only Ray-Ban Meta Smart Glasses owners are supposed to see: post a Story from the glasses and Instagram attaches a special glasses icon with a 3D "spin view" parallax effect, because the photo's EXIF metadata says Meta AI / Ray-Ban Meta Smart Glasses 2. The glasses cost around $299. Meta Glasses Converter (https://habeebbk.github.io/metarayban/) is a free, single-page web tool that takes any ordinary JPG and rebuilds it to the exact Ray-Ban Meta format — 3024×4032 pixels, camera EXIF rewritten to "Meta AI", GPS and other identifying tags wiped — entirely inside your browser.

We opened the site, read its full source code, and traced exactly which metadata fields it writes and deletes, so you know precisely what it does before you hand it a photo.

🎯 Key Takeaways

Meta Glasses Converter is a free, no-login, 100% client-side web app hosted on GitHub Pages under the account habeebbk, first published on September 1, 2026 and updated for mobile on September 2.
Its job is one conversion: any JPG → 3024×4032 px portrait with EXIF Make = Meta AI and Model = Ray-Ban Meta Smart Glasses 2 — the exact signature Instagram looks for when it enables the Ray-Ban Meta 3D Spin View effect on Stories.
It deletes sensitive metadata at the same time: GPS coordinates, software watermarks, lens details, and maker notes are stripped before the new camera tags are injected.
One tap does everything: the ALL-IN-ONE button converts, copies the photo as Base64 to your clipboard, and opens the native Save/Share sheet (or downloads the file on desktop).
Real limits we verified in the code: it accepts JPG/JPEG only (no PNG, WebP, or HEIC), it stretches rather than crops to fill the 3:4 frame, and the EXIF survives only if you don't re-share the image through chat apps, which re-compress and strip metadata.

Meta Glasses Converter Official Website

Meta Glasses Converter is a client-side photo converter for Ray-Ban Meta Smart Glasses format.

Official app: https://habeebbk.github.io/metarayban/
Creator: habeebbk (independent developer; GitHub account with contact email habeebbk950@gmail.com)
Price: Free — no payments are requested anywhere on the page
Login required: No — there is no account, sign-up, or Google/Discord login
Platform: Web (static single HTML page hosted on GitHub Pages, mobile-first design)
Main use: Convert ordinary JPG photos into Ray-Ban Meta Smart Glasses format (3024×4032 + Meta AI EXIF) — most often to unlock Instagram's Ray-Ban Meta Story effects
Last checked: September 3, 2026

Visit Meta Glasses Converter

We are not the official developer of Meta Glasses Converter. This page helps users find, understand, and use the product.

What Is Meta Glasses Converter?

Meta Glasses Converter is a one-page tool that solves a strangely specific problem: photos taken with Ray-Ban Meta (Gen 2) smart glasses carry a 3024×4032 resolution and a distinctive EXIF signature — the camera make reads "Meta AI" and the model reads "Ray-Ban Meta Smart Glasses 2". Platforms like Instagram detect that signature and reward it with exclusive Story features, most notably the 3D Spin View effect, where viewers can tilt their phone and the photo rotates in parallax. If your photo came from an iPhone or a Samsung, none of that appears — no matter how good the picture is.

The converter rewrites your photo's identity:

It rescales your image to 3024×4032 (the 12 MP portrait format of the Gen 2 glasses), correctly handling EXIF orientation — a sideways phone photo comes out upright.
It rebuilds the camera metadata: Make → Meta AI, Model → Ray-Ban Meta Smart Glasses 2, pixel dimensions and sRGB color-space tags set to match genuine glasses captures.
It cleans you out of the file first: GPS coordinates, the software/host-computer watermark, lens make/model strings, and camera maker notes are deleted, so the converted file carries none of your own device's trail.
It hands the result straight to your phone: converted image preview (tap and hold to save), Base64 copy, and the native share sheet via the Web Share API.

The experience difference versus a general-purpose editor: there is nothing to configure. No settings, no quality sliders, no accounts — you tap a photo, press one button, and get a file that is byte-for-byte shaped like a glasses capture.

How to Use Meta Glasses Converter

Open the official website — https://habeebbk.github.io/metarayban/ — in any mobile or desktop browser. No installation, no extension.
Pick a photo. Tap 📷 Take Photo to shoot directly through your camera, or 🖼️ Photo Library (the big ⚡ drop zone does the same) to choose an existing picture. Only JPG/JPEG files are accepted — PNG, WebP, and HEIC show an error.
Press ⚡ ALL-IN-ONE: Convert, Copy & Save. The app rescales the image to 3024×4032, rewrites the EXIF, and does three things at once: shows the converted preview (tagged "3024×4032 Ready"), copies the raw Base64 string to your clipboard, and opens your phone's share sheet — choose Save Image to drop it into your camera roll. On desktop it falls back to a normal download named meta-glasses-converted.jpg.
Post it while the metadata is intact. To get the Ray-Ban Meta effects on Instagram, share the saved file directly into a new Story. Do not route it through WhatsApp, Telegram, or Messenger first — chat apps re-compress images and strip EXIF, which removes the glasses signature.

The two secondary buttons (📋 Copy Base64, 💾 Save / Share) re-run the copy and save steps individually if you skipped or cancelled them the first time.

What Exactly Does It Change? (Verified in Source Code)

We read the app's JavaScript (it loads the open-source piexif.js 1.0.6 library from cdnjs and uses the HTML5 Canvas). Here is the full metadata transformation:

EXIF field	Your original photo	After conversion
Make	Apple / Samsung / Google…	Meta AI
Model	iPhone 15, Galaxy S24…	Ray-Ban Meta Smart Glasses 2
Pixel dimensions	Variable	3024 × 4032
Orientation	1–8 (varies)	1 (pixels physically rotated upright)
ColorSpace	Varies	sRGB (tag 1)
GPS block	May contain lat/long/altitude	Deleted entirely
Software / HostComputer	e.g. "iOS 18.2"	Deleted
LensMake / LensModel / LensSpecification	Your phone's lens data	Deleted
MakerNote	Proprietary camera data	Deleted

One thing to know before you convert a favorite photo: the resize step stretches the image to fill 3024×4032 — it does not crop to preserve your original aspect ratio. A landscape photo will look vertically stretched. Portrait or square photos survive the conversion much better, and re-encoding happens at JPEG quality 0.95, so there is a slight (usually invisible) quality loss.

Is Meta Glasses Converter Safe?

Based on the page source and live testing on September 3, 2026:

Your photo never leaves your device. The entire app is one static HTML file with client-side JavaScript; there is no upload endpoint, no form, and no network call that carries image data. Processing happens in your browser via Canvas + piexif.js.
No login, no tracking, no ads. We found no analytics scripts, no ad networks, and no third-party logins. The only external resources are Google Fonts (Plus Jakarta Sans) and the piexif.js library on cdnjs.
It actively removes private data — GPS coordinates, device serials (maker notes), and software watermarks are stripped from every converted file.
No payments are requested anywhere on the page, and the domain is plain GitHub Pages (habeebbk.github.io), so the code you run is exactly what's published in the public metarayban GitHub repository.

The honest caveats: the tool's purpose is to make a non-glasses photo carry glasses metadata. Using it to unlock an Instagram effect is harmless fun — but presenting a converted photo as a genuine glasses capture (to a buyer, a contest, or a client) is misrepresentation, and EXIF metadata is trivially easy for platforms to fake-check or for recipients to inspect. Also note the opposite risk: some people assume "EXIF says Ray-Ban Meta, therefore authentic." As this very tool demonstrates, metadata is editable — treat it as a weak signal, not proof.

Why Is Meta Glasses Converter Popular?

The Instagram Ray-Ban Meta Story effect is the engine. Instagram reserves the glasses icon and 3D spin/parallax Story effect for photos with genuine Meta AI EXIF and 3024×4032 portrait framing. That turned "Ray-Ban Meta photo converter" into a search trend of its own — at least one competing converter (OD2's Ray-Ban Meta Spin View Converter) exists purely for this trick and documents the same detection criteria: matching Make/Model strings, exact pixel dimensions, and an sRGB color-space tag.
The glasses are expensive; the format is free. A $299 hardware purchase versus a one-page website is an easy decision for someone who just wants the effect.
It is new and moving fast. The GitHub repository shows the app was created September 1, 2026 and received mobile-experience fixes the very next day (Web Share API support, camera/gallery triggers, safe-area UI) — a quick iteration loop aimed squarely at phone users.
Beyond Instagram, the same demand shows up elsewhere: Ray-Ban Meta communities have active threads from people hunting for original photos "with metadata intact." Meta Glasses Converter appears to be spreading through direct sharing and word-of-mouth in exactly those circles; there is no clear public source showing where the trend originated.

Meta Glasses Converter Not Working?

If the page won't load or a conversion misbehaves, try:

Refresh the page (the app is a single file — a hard reload fixes most stale-cache issues).
Open it in another browser; on iOS, Safari handles the Web Share / save-to-photos flow best.
Temporarily disable ad blockers or privacy extensions — they can block the cdnjs script the EXIF engine depends on. Without piexif.js, conversion fails.
Confirm your file is a JPG/JPEG. PNG, WebP, and HEIC files are rejected with an error — export to JPG first (iPhones: Settings → Camera → Formats → Most Compatible, or share out of Photos as JPEG).
Check your photo's aspect ratio. The output is always 3024×4032 portrait; a landscape photo gets stretched — that's a design limitation, not a bug.
If the "Save" step does nothing on desktop, use the preview image instead: tap and hold (mobile) or right-click (desktop) to save manually.
Check whether the GitHub Pages deployment is still online — it's a free static host, and the developer may push updates at any time.

If the site is confirmed offline:

The original Meta Glasses Converter website appears to be unavailable as of September 3, 2026. The source remains viewable in the public habeebbk/metarayban repository on GitHub.

Meta Glasses Converter Alternatives

OD2 Ray-Ban Meta Spin View Converter (od2.in/meta-glasses-converter) — the closest competitor, built for the same Instagram trick; accepts JPG/PNG/WebP and crops "native fill" instead of stretching, though it lacks the Base64 copy feature.
ExifTool (exiftool.org) — the desktop power-tool route: a free command-line utility that can set Make/Model, resize, and strip GPS on any OS, with full control but no friendly buttons.
The official Meta AI app — if you actually own Ray-Ban Meta or Oakley Meta glasses, this is the legitimate way to import, manage, and share real glasses captures with their original metadata.

Frequently Asked Questions

What is the official Meta Glasses Converter website?

The official website is https://habeebbk.github.io/metarayban/ — a single-page app titled "Meta Glasses Converter — Mobile First." Beware of copycats; the tool's code is also published in the public habeebbk/metarayban GitHub repository.

Is Meta Glasses Converter free?

Yes. The tool is completely free with no ads, no premium tier, and no payment prompts of any kind.

Do I need an account to use Meta Glasses Converter?

No. There is no sign-up, login, or third-party authorization — you open the page and start converting.

Who created Meta Glasses Converter?

An independent developer publishing under the GitHub username habeebbk (contact: habeebbk950@gmail.com). The repository history shows the app was first committed on September 1, 2026.

Is Meta Glasses Converter still available?

Yes — the site was online and fully functional when we checked on September 3, 2026. It is hosted free on GitHub Pages, so brief downtime during updates is possible.

Why does my converted photo lose the glasses effect after sending it to a friend?

Chat apps like WhatsApp, Telegram, and Messenger re-compress images and strip EXIF metadata in transit. Save the converted file to your camera roll and upload it to Instagram directly.

Originally published at: Meta Glasses Converter – Official Website, What It Is & How to Use

Magic Layers Review 2026: AI Turns Any Image into Editable Layers

cz — Thu, 27 Aug 2026 07:30:15 +0000

Magic Layers Review 2026: AI Turns Any Image into Editable Layers

Every designer knows the pain: the final image is perfect, but the project file is gone — the source was never shared, or the laptop that held it is long gone. Magic Layers (https://magiclayers.net/) is a new AI web tool built for exactly that moment: it takes one flat PNG or JPEG and splits it back into its individual visual elements as editable layers.

In this review, we walk through what Magic Layers actually does, how it works, what it costs, the honest limits of its output, and how it compares to the background removers you already know.

🎯 Key Takeaways

Magic Layers is an "image-to-layers" AI tool: upload one flat PNG or JPEG and get back a base image plus named transparent PNG layers for the text, subject, decorations, and background.
The separation is inferred from pixels alone — no project file, no source history, no metadata needed.
You only pay for what you get: each generated layer costs 2 credits, and the layer count you choose (2–12) is your price ceiling.
Honest limit: output is transparent raster PNGs, not a recovered Photoshop or Figma file — live text, fonts, and vector paths cannot come back.
Pricing starts at $29/month (400 credits, up to 200 layers); no free tier, but files are private and auto-deleted after 7 days.

What Is Magic Layers?

Magic Layers is a web-based AI tool that performs image layer separation: taking a single, already-rendered image and splitting it back into the visual elements it was built from — background, subject, text, and decorations — as separate images with transparency.

You upload one PNG or JPEG (up to 30 MB, at least 512×512 px), choose a target layer count between 2 and 12, and the AI returns a base image plus one transparent PNG per element it finds. Every layer comes with a name (like "Gold circle" or "Headline"), a short description, and its detected position in the original image.

Magic Layers at a Glance

Detail	Info
Official website	https://magiclayers.net/
Category	AI image layer separation / image-to-layers
Developer	Independently built and operated (not affiliated with Adobe, Figma, or Canva)
Price	$29–$149/month plans, or one-time credit packs
Login required	Yes (credits are tied to an account)
Platform	Web app, runs on Cloudflare Workers
Input format	PNG or JPEG, up to 30 MB, min 512×512 px
Layers per job	2–12, chosen by you before the job starts
Output format	Transparent PNG layers + base image
Storage	Private to your account, kept for 7 days
Last checked	August 27, 2026

The killer scenario is the one its About page names directly: a visual exists but its project file does not. Because the separation is inferred from pixels, Magic Layers works on images you received as a screenshot, a PDF slide, a shared export, or a design from someone else — cases where no tool could ever "open the source."

How to Use Magic Layers

Getting layered output from a flat image takes three steps, all on the homepage:

Upload your image. Drop a PNG or JPEG (up to 30 MB, at least 512×512 px) into the uploader. The site notes that files stay private and are never shown to other users.
Choose how many layers. Use the slider to pick a target between 2 and 12 layers. The credit cost is displayed before you commit — for example, a 5-layer target shows "Up to 10 Credits."
Review and download. The job runs on a third-party AI model (ByteDance Volcano Engine Ark / Seedream) and returns a base image plus one transparent PNG per element. Click any layer to see exactly where it sat in the original, then download only the layers you need.

💡 Pro tip: pick your layer target as a real intent, not a guess — the chosen count is both your guide and your price ceiling. You are never charged for more layers than you asked for, and if the image contains fewer meaningful elements, you get fewer layers and pay less.

What You Get Back

Magic Layers isn't a folder of anonymous crops. Each separated element arrives ready to use in the tools designers already work in:

Transparent PNG layers — every element has a clean alpha channel, so it drops straight into Photoshop, Figma, Canva, a slide deck, or a game engine.
Named and described — the AI labels each layer ("Gold circle," "Headline," "Product bottle"), so you know what a file is before you open it.
Position per layer — each layer keeps its detected position and stacking order; click a layer to highlight it in the original image.

Magic Layers vs. Background Remover

The simplest way to understand the product is to compare it with the tools most people already have in mind. A background remover (like remove.bg) gives you one subject on transparent background and discards everything else — text and decorations stay flattened, and you rebuild the rest by hand. Magic Layers separates every major element:

	Background remover	Magic Layers
Output	One subject cutout	Every major element separated
Naming	Anonymous	Each layer named and described
Text	Stays flattened	Split from subject and background
Decorations	Discarded	Returned as their own layers
Cost model	Flat per image	Per layer, you choose 2–12

Magic Layers Pricing

Every generated layer costs 2 credits, including the base image. Before a job starts, Magic Layers holds the maximum charge for your chosen target, then settles to the actual number of layers produced. Failed jobs release the hold back to your balance.

Plan	Price	Credits/month	Layers
Basic	$29/month	400 credits	up to 200
Pro	$79/month	1,200 credits	up to 600
Studio	$149/month	2,400 credits	up to 1,200

All plans include "only pay for layers you get," 7-day file retention, and cancel-anytime billing through Stripe. One-time credit packs are also available on the pricing page, which makes the tool usable for occasional one-off jobs without a subscription.

What People Use Image Layer Separation For

Magic Layers names six real-world use cases, and they are all variations of the same need: a finished visual needs to become editable again.

Marketing creative variations — split a finished campaign visual into background, headline, product, and badges, then test new copy and layouts without hunting for the lost source file.
Social posts and thumbnails — recompose one thumbnail into vertical stories, square posts, and wide video covers instead of masking the subject out by hand.
Presentation assets — pull charts, icons, labels, and shapes out of a flat slide screenshot and rebuild a clean, editable composition.
Game and UI prototyping — turn flattened concept art and interface mockups into separate characters, panels, and props for parallax scenes and clickable prototypes.
E-commerce imagery — separate product, price label, and background so you can restage a shot for a new placement or marketplace.
Studying a design — step through how a visual is built; useful for learning composition and planning your own original version.

Is Magic Layers Safe?

Based on what the site itself publishes, here is what we can verify:

You must sign in to use the tool; credits and generated files are tied to your account.
Images are private — uploads and generated layers are never published or shown to other users.
7-day retention — input and output objects are configured for 7-day retention (under the site's R2 storage lifecycle rules), after which preview and download links stop working and files are removed.
No third-party login or ad networks were observed on the public pages; billing goes through Stripe subscriptions.
Infrastructure — the site runs on Cloudflare Workers, with D1 for account/billing records and R2 for temporary image storage.
The company is honest about its limits — an About page documents exactly what the tool can and cannot do, and contact is a monitored address (contact@magiclayers.net), not a no-reply.

One thing to keep in mind: separation is a technical operation, not a licence — running an image through the tool doesn't grant any rights in the source artwork.

What Magic Layers Cannot Do

The About page is refreshingly direct about the limits, and you should read them before buying:

The layers are transparent raster PNGs, not a recovered document. Live text, fonts, vector paths, and effects that only existed in the authoring file cannot be brought back from a flat image.
The target layer count is guidance, not a guarantee. A simple image may contain fewer meaningful elements than you asked for — you get fewer layers and pay less.
Boundaries, names, and quality vary by image. Busy or low-contrast compositions separate less cleanly than graphic, high-contrast ones.

⚠️ Bottom line: Magic Layers recovers pixels, not design source files. If you need to re-edit the text copy, you'll still want an editor — but now you can select and restyle the text element instead of masking around it.

Magic Layers Not Working?

If the site won't load or a job fails, the standard web-app checklist applies:

Refresh the page (headless/background tabs can interact badly with the credits display).
Open it in another browser or an incognito window.
Disable ad blockers temporarily.
Confirm your image meets the limits: up to 30 MB, at least 512×512 px, PNG or JPEG.
Check whether your credit balance covers the selected target — the job shows the max charge before it starts.
Try again later if the service is being updated; for billing or persistent bugs, contact contact@magiclayers.net.

Magic Layers Alternatives

If layer separation isn't quite what you need, these are the genuinely close options:

remove.bg — the classic background remover: one subject, one cutout. Simpler and faster for that single use case.
Photopea — free browser-based Photoshop alternative for manual layer work; no AI separation, but full control.
Figma / Canva — the right tools if you still have (or can rebuild) the original design; Magic Layers' output is designed to slot directly into their layer panels.

Frequently Asked Questions

What is the official Magic Layers website?

The official website is https://magiclayers.net/.

Is Magic Layers free?

No free tier, but there's an upfront-displayed cost model: each generated layer costs 2 credits, and you're only charged for the layers you actually get. Monthly plans start at $29/month (400 credits) and one-time credit packs are available.

Do I need an account to use Magic Layers?

Yes. Credits are attached to your account and require signing in to run jobs.

How many layers will I get?

You choose the target between 2 and 12 before the job starts. If an image has fewer meaningful elements, you get fewer layers — and pay less.

What image formats does Magic Layers support?

PNG and JPEG up to 30 MB and at least 512×512 px. Because JPEG doesn't support an alpha channel, every upload returns PNG layers.

Can I use the layers in commercial work?

The site positions the layers for commercial pipelines (marketing creatives, e-commerce, game prototypes), but separation doesn't grant any rights to the source artwork — commercial use still depends on your rights in the original image.

Is Magic Layers still available?

Yes — the site is live and was last verified on August 27, 2026.

Conclusion

Magic Layers solves a genuinely common problem that existing tools only half-solve: making a finished flat image editable again. It won't bring back your original design file, and it says so plainly — but it will give you named, positioned, transparent layers out of any PNG or JPEG, so you can move, replace, or restyle any part of the image without redoing the work by hand. If you regularly work with marketing visuals, thumbnails, slide exports, or flattened mockups whose source files are long gone, it's a tool worth trying.

Visit Magic Layers

Originally published at: Magic Layers Review 2026: AI Turns Any Image into Editable Layers

Qwen3.8-Flash-Next (2026): The Complete Guide to Qwen’s Qwen4-Preview Architecture Model

cz — Wed, 26 Aug 2026 14:08:04 +0000

Qwen3.8-Flash-Next (2026): The Complete Guide to Qwen's Qwen4-Preview Architecture Model

🎯 Core Takeaways (TL;DR)

Qwen3.8-Flash-Next is Alibaba Qwen's open-weight preview of the architecture that will underpin Qwen4 — a 125B-parameter MoE model that activates just 6B parameters per token (plus a 51B n-gram embedding), delivering frontier-adjacent intelligence at a fraction of the compute cost.
The headline is efficiency: Qwen3.8-Flash-Next scored DeepSWE 1.1 at 58.7, SWE-bench Pro at 62.5, and 91.9 on LiveCodeBench v6 — beating Claude Opus 4.6 Max on most benchmarks despite being a "mid-tier Flash" release. Training cost came in at roughly one-ninth of Qwen3.7-Plus.
Qwen3.8-Flash-Next introduces three genuinely new architectural building blocks — Qwen Sparse Attention (QSA), Gated Residual, and N-gram Embedding — rethinking how the core components of a modern LLM interact at scale.
Qwen3.8-Flash-Next ships with a native 262,144-token (256K) context window, extensible to 1M tokens via YaRN, with Qwen reporting prefill up to 7.6× faster and decode up to 4.9× faster at the 1M-token mark. The official hosted version, Qwen3.8-Flash, adds 1M context by default and built-in tools.

What Is Qwen3.8-Flash-Next?
Qwen3.8-Flash-Next Architecture & Specs
Qwen3.8-Flash-Next Benchmarks: The Efficiency Leap
Why "Flash" Matters: Qwen3.8-Flash-Next Efficiency
Running Qwen3.8-Flash-Next (Deployment & API)
Qwen3.8-Flash-Next vs the Competition
FAQ
Summary & Recommended Actions

What Is Qwen3.8-Flash-Next?

Qwen3.8-Flash-Next is the newest open-weight release from Alibaba's Qwen team, and it marks a pivotal shift in the company's roadmap. Unlike Qwen3.8-Max (the 2.4T-parameter flagship) or Qwen3.8-27B (the 27B dense model), Qwen3.8-Flash-Next is the first open-weight model built on a fundamentally reworked architecture — what the model card calls "an experimental preview of the architecture that will underpin Qwen4."

The name tells the story. "Flash" is Qwen's mid-tier, efficiency-first brand: a model that trades some raw ceiling for dramatically lower cost and faster inference. "Next" signals that this is the architectural blueprint for the coming generation. In Qwen3.8-Flash-Next, the old pairing of Gated DeltaNet with Gated Attention has been reworked into Gated DeltaNet plus Qwen Sparse Attention (QSA), alongside two other brand-new components: Gated Residual and N-gram Embedding.

The result is a model that Qwen positions as delivering "most of the reasoning and coding capability of its larger Qwen3.8 line while running at a fraction of the compute cost." As the official announcement frames it: the question is no longer how much we can scale, but how efficiently we can do so.

💡 Professional Tip: Qwen3.8-Flash-Next is available on Hugging Face at Qwen/Qwen3.8-Flash-Next under the qwen-community-1.0 license (open weights, not fully permissive Apache 2.0). For managed inference, the official Qwen3.8-Flash on Qwen Cloud is the production-hardened version with 1M context by default and official built-in tools.

Architecture and Specs

Here's what's under the hood of Qwen3.8-Flash-Next:

Spec	Qwen3.8-Flash-Next
Model type	Causal LM with vision encoder
Total parameters	125B MoE + 51B n-gram embedding + 4B MTP
Activated parameters per token	6B
Mixture of Experts	512 experts (10 routed + 1 shared activated), expert intermediate dim 640
Hidden dimension	2,560
Number of layers	48
Hidden layout	12 × (3 × (Gated DeltaNet → MoE) → 1 × (Qwen Sparse Attention → MoE))
Vision	Yes (image + text input, native multimodal)
Native context	262,144 tokens (256K)
Extensible context	Up to 1,000,000 tokens (YaRN)
License	qwen-community-1.0

The defining feature of Qwen3.8-Flash-Next is that it's not just a bigger or smaller model — it's an architectural redesign. Three new mechanisms stand out:

1. Hybrid Attention with Qwen Sparse Attention (QSA)

The biggest change is in how Qwen3.8-Flash-Next handles attention. Instead of selecting individual tokens, QSA operates at the micro-block level — it picks entire blocks of tokens to attend to, using a lightweight indexer (MQA with 4 query heads and 1 shared key head, 128-dim). This dramatically cuts long-context latency, which matters as agentic workloads — tasks with huge tool-call histories and long codebases — dominate real usage. Budget: 512 blocks, or 2,048 tokens.

2. Gated Residual

Deep LLM training is only manageable because of residual streams with normalization. Qwen3.8-Flash-Next refines this with a Gated Residual that modulates information flowing through widened residual streams via an element-wise, data-dependent read gate and a per-branch scalar write gate (4 branches, bottleneck rank 320). The result is finer-grained expressiveness across layers while preserving training stability and keeping inference overhead low.

3. N-gram Embedding

Qwen3.8-Flash-Next scales parameters along a new axis: embeddings rather than expert weights. By indexing with short n-grams (20M bigrams/trigrams at layer 2, with 51B of embedding parameters), the model achieves parameter scaling that requires less computation and is far more amenable to memory offloading than a pure MoE — highly efficient for memory-constrained accelerators. This is why Qwen3.8-Flash-Next can hold 125B+ parameters while activating only 6B.

4. A Tailored Training Recipe

Training memory and cost were optimized with a tailored recipe that applies Muon and AdamW optimizers to specific weight categories. Guided by refitted scaling laws, Qwen eliminated traditional batch-size warmups and started directly at the target batch size — substantially reducing optimizer steps while safely supporting larger learning rates. This is a large part of how training cost dropped to roughly one-ninth of Qwen3.7-Plus.

✅ Best Practice: For agentic work with Qwen3.8-Flash-Next, use thinking mode (on by default) with reasoning_effort="xhigh" for complex planning. But remember: higher reasoning_effort isn't always slower overall — lower effort can cause insufficient analysis, more failures, and retries that inflate total latency and token spend.

Benchmarks

The reason momentum around Qwen3.8-Flash-Next built so quickly is the shape of its benchmark curve: a "Flash" (mid-tier) model beating a frontier flagship on most tests. Here are the official language benchmarks, with comparison to prior Qwen models, DeepSeek-V4-Flash-0731, and Claude Opus 4.6 Max:

Benchmark	Qwen3.8-Flash-Next	Qwen3.8-27B	Qwen3.7-Plus	DeepSeek V4 Flash 0731	Opus 4.6 Max
Activated params	6B	27B	17B	13B	–
DeepSWE 1.1	58.7	42.2	16.5	54.4	–
SWE-bench Pro	62.5	61.7	55.8	56.0	53.4
SWE-bench Multilingual	81.0	73.8	75.8	–	77.5
NL2Repo-Bench	48.1	42.3	41.1	54.2	47.6
CoWorkBench	73.9	70.7	65.1	45.1	68.2
JobBench	55.7	33.4	27.6	41.3	36.6
Agents' Last Exam (score)	51.2	42.9	33.6	–	–
Toolathlon Verified	73.5	67.1	50.6	70.3	–
IFBench	81.3	79.5	79.1	79.2	62.5
GPQA Diamond	91.7	89.2	90.3	90.8	91.3
HLE	35.9	30.8	34.7	33.8	40.0
LiveCodeBench v6	91.9	90.3	89.6	90.6	88.8

The message is unmistakable. Qwen3.8-Flash-Next leads on DeepSWE 1.1 (58.7), SWE-bench Pro (62.5), SWE-bench Multilingual (81.0), CoWorkBench (73.9), JobBench (55.7), Toolathlon Verified (73.5), and LiveCodeBench v6 (91.9) — all with only 6B activated parameters. Claude Opus 4.6 Max maintains its edge on GPQA Diamond (91.3) and Humanity's Last Exam (40.0), and DeepSeek-V4-Flash wins NL2Repo-Bench (54.2).

Vision-Language Benchmarks

Qwen3.8-Flash-Next is also a native vision-language model. On multimodal agentic and general intelligence tests:

Benchmark	Qwen3.8-Flash-Next	Qwen3.8-27B	Qwen3.7-Plus	Opus 4.6 Max
ClawEval-MM (Pass@3 / avg)	64.4 / 60.4	57.4 / 56.9	57.4 / 60.1	52.5 / 54.7
RecreationBench	49.9	47.1	30.2	–
AndroidWorld	84.5	81.9	81.0	62.0
OSWorld 2.0 (binary / partial)	19.4 / 52.3	19.4 / 48.0	2.8 / 21.5	–
Vision2Web	64.0	62.9	42.1	–
ERQA	72.3	65.5	69.8	40.8
LVBench (long video)	76.6	72.4	76.2	63.0
RealWorldQA	88.5	85.9	86.9	73.9
MathVision (with CI)	95.7	94.6	88.7	65.5
CharXiv RQ (with CI)	90.6	90.2	85.9	66.0

Qwen3.8-Flash-Next beats Claude Opus 4.6 Max across computer use, mobile use, long-video understanding, embodied perception, and visual math — all from a model that activates just 6B parameters.

⚠️ Attention: These are Qwen's own reported numbers, not yet independently verified. Treat the deepest benchmark claims as directional until third-party leaderboards (like a DeepSWE or SWE-bench Pro leaderboard) confirm them.

Why "Flash" Matters

Positioning matters as much as raw scores. Qwen3.8-Flash-Next is deliberately priced and sized as a mid-tier, efficiency-first model — not a flagship. That framing makes its benchmark results genuinely surprising: a cheap, low-activation model taking the lead on the agentic-coding and long-horizon benchmarks that enterprises care most about.

The economics are the story. Qwen claims training Qwen3.8-Flash-Next cost roughly one-ninth of Qwen3.7-Plus, while beating it on nearly every benchmark. This is the same efficiency direction Qwen took with Qwen3.8-27B a few weeks earlier — position a smaller/cheaper model against far larger rivals and still come out competitive. Flash-Next takes the argument further by redesigning the architecture itself, so the savings come from how the model computes, not just how many parameters it has.

For anyone paying for API tokens or running their own GPUs, Qwen3.8-Flash-Next's activation ratio (6B active out of 125B) is the practical headline: most of the intelligence, a fraction of the compute.

💡 Professional Tip: If your workload is dominated by long-context agent tasks — large tool-call histories, chat logs, multi-file codebases — Qwen3.8-Flash-Next's QSA and 256K→1M context extension are purpose-built for you. Qwen reports prefill up to 7.6× faster and decode up to 4.9× faster at the 1M-token mark than the prior architecture.

Running Qwen3.8-Flash-Next

Getting Qwen3.8-Flash-Next running is straightforward. Qwen recommends API-based integration for most users, and for self-hosting it ships as Transformers-compatible weights usable with SGLang, vLLM, and TokenSpeed.

Supported Inference Frameworks

Framework	Notes
SGLang	Qwen3.8-Flash-Next Cookbook — recommended for production/high throughput
vLLM	Qwen3.8-Flash-Next Recipe
TokenSpeed	Qwen3.8-Flash-Next Recipe
KTransformers	Recommended for high-throughput serving
Qwen Cloud	Official hosted Qwen3.8-Flash — 1M context by default + built-in tools

[!Important]
Inference efficiency and throughput vary significantly across frameworks. Qwen strongly recommends using the latest framework versions, and for production or high-throughput workloads, dedicated serving engines such as SGLang, KTransformers, or vLLM.

API Usage

Qwen3.8-Flash-Next operates in thinking mode by default, generating reasoning content (signified by \n...\n\n) before the final answer. You can control thinking behavior with enable_thinking, preserve_thinking, and reasoning_effort (levels: xhigh, medium, low).

Recommended sampling parameters:

Thinking Mode: temperature=1.0, top_p=0.95, top_k=20, min_p=0.0, presence_penalty=0.0, repetition_penalty=1.0
Instruct (non-thinking) mode: temperature=0.7, top_p=0.80, top_k=20, min_p=0.0, presence_penalty=1.5, repetition_penalty=1.0

Text-only example (OpenAI-compatible API):

from openai import OpenAI

client = OpenAI()  # set OPENAI_BASE_URL and OPENAI_API_KEY

completion = client.chat.completions.create(
    model="Qwen/Qwen3.8-Flash-Next",
    messages=[{"role": "user", "content": "Write a Python function to merge two sorted linked lists."}],
    extra_body={
        "chat_template_kwargs": {
            "enable_thinking": True,   # on by default
            "preserve_thinking": True, # on by default
        },
    },
    reasoning_effort="xhigh",          # xhigh by default; levels xhigh, medium, low
    stream=True,
    stream_options={"include_usage": True},
)

Qwen3.8-Flash-Next also accepts image input through the standard OpenAI image_url content type, making it a drop-in native vision-language model for the Chat Completions API.

Comparison

How does Qwen3.8-Flash-Next stack up against the models it's being compared to?

Model	Total params	Activated	DeepSWE	SWE-bench Pro	Local-friendly	Vision
Qwen3.8-Flash-Next	125B	6B	58.7	62.5	✅ (efficient)	✅ native
Qwen3.8-27B	27B dense	27B	42.2	61.7	✅ (consumer GPU)	✅
DeepSeek V4 Flash 0731	284B	13B	54.4	56.0	⚠️ (larger)	❌
Qwen3.7-Plus	397B	17B	16.5	55.8	⚠️	✅
Claude Opus 4.6 Max	frontier	–	–	53.4	❌	✅

The clearest takeaway: Qwen3.8-Flash-Next beats not only its bigger, more expensive sibling Qwen3.7-Plus, but also the frontier Claude Opus 4.6 Max on the majority of shared benchmarks — while activating a mere 6B parameters. Its main losses are narrow: DeepSeek-V4-Flash on NL2Repo-Bench, and Claude on the hardest frontier-reasoning tests (GPQA Diamond and HLE). For agentic coding and long-horizon work, Qwen3.8-Flash-Next is currently the efficiency king.

FAQ

Q: What is Qwen3.8-Flash-Next?

A: Qwen3.8-Flash-Next is Alibaba Qwen's open-weight preview of the Qwen4 architecture — a 125B-parameter Mixture-of-Experts vision-language model that activates only 6B parameters per token, plus a 51B n-gram embedding. It introduces Qwen Sparse Attention, Gated Residual, and N-gram Embedding, and targets coding, agent, and long-context workloads with high efficiency.

Q: How many parameters does Qwen3.8-Flash-Next activate?

A: Only 6B parameters are active per token out of 125B total, with 51B additional n-gram embedding parameters and 4B MTP. This low activation ratio is the core efficiency design of Qwen3.8-Flash-Next.

Q: How good is Qwen3.8-Flash-Next on benchmarks?

A: Qwen3.8-Flash-Next scores DeepSWE 1.1 at 58.7, SWE-bench Pro at 62.5, SWE-bench Multilingual at 81.0, Toolathlon Verified at 73.5, and LiveCodeBench v6 at 91.9 — beating Claude Opus 4.6 Max on most shared benchmarks with only 6B activated parameters.

Q: What is the context length of Qwen3.8-Flash-Next?

A: Qwen3.8-Flash-Next natively supports 262,144 tokens (256K) and can be extended up to 1,000,000 tokens via YaRN scaling. With Qwen's reworked attention kernels, prefill is up to 7.6× faster and decode up to 4.9× faster at the 1M-token mark.

Q: Is Qwen3.8-Flash-Next open source?

A: Qwen3.8-Flash-Next is released as open weights under the qwen-community-1.0 license (not Apache 2.0), available on Hugging Face at Qwen/Qwen3.8-Flash-Next and ModelScope. Commercial use is subject to the community license terms.

Q: Can I run Qwen3.8-Flash-Next locally?

A: Yes. Qwen3.8-Flash-Next is Transformers-compatible and officially supported by SGLang, vLLM, TokenSpeed, and KTransformers. Because it activates only 6B parameters, it is far more memory-friendly than its parameter count suggests.

Q: Does Qwen3.8-Flash-Next support images?

A: Yes. Qwen3.8-Flash-Next is a native vision-language model with image + text input through the OpenAI-compatible Chat Completions API. It scores 88.5 on RealWorldQA, 95.7 on MathVision (with CI), and 90.6 on CharXiv RQ (with CI).

Q: Does Qwen3.8-Flash-Next support tool calling and thinking mode?

A: Yes. Qwen3.8-Flash-Next runs in thinking mode by default, with enable_thinking, preserve_thinking, and reasoning_effort controls (xhigh/medium/low). It supports tool calling and returns reasoning content alongside the final answer.

Q: What is Qwen3.8-Flash (the hosted version)?

A: Qwen3.8-Flash is the official Qwen Cloud production version built from Qwen3.8-Flash-Next, with a 1M context window by default and official built-in tools — recommended if you want managed inference rather than self-hosting.

Q: When was Qwen3.8-Flash-Next released?

A: Qwen3.8-Flash-Next open weights were released on August 26, 2026, alongside the technical report and Qwen Cloud availability of the production Qwen3.8-Flash version.

Summary & Recommended Actions

Qwen3.8-Flash-Next is one of the most important efficiency releases of 2026. It is the first open-weight glimpse of the Qwen4 architecture, and it proves that a "mid-tier Flash" model — just 6B activated parameters — can top a frontier flagship on the benchmarks that matter most for real agentic work: DeepSWE 1.1 (58.7), SWE-bench Pro (62.5), CoWorkBench (73.9), and LiveCodeBench v6 (91.9). With native vision, a 256K→1M context window, QSA-driven long-context speedups, and roughly one-ninth the training cost of Qwen3.7-Plus, it redefines the compute-to-intelligence ratio.

The caveats: these are Qwen's own benchmarks pending independent verification; the license is qwen-community-1.0, not fully permissive; and on the hardest frontier-reasoning tests (GPQA Diamond 91.3, HLE 40.0) Claude Opus 4.6 Max still leads. But for cost-sensitive, long-context, agentic and multimodal workloads, Qwen3.8-Flash-Next sets a new benchmark.

Your next steps:

Try the API — test Qwen3.8-Flash-Next through the OpenAI-compatible Chat Completions API (via a local SGLang/vLLM serve or Qwen Cloud) on a real agentic coding task.
Benchmark it against your stack — compare Qwen3.8-Flash-Next side-by-side with your current model on DeepSWE-style and long-context tasks to see the cost/perf win.
Watch the architecture — since Qwen3.8-Flash-Next previews Qwen4, follow the Qwen3.8-Flash-Next blog and technical report for the full-generation rollout.

Sources: Qwen3.8-Flash-Next on Hugging Face · Qwen3.8-Flash-Next blog · Qwen3.8-Flash-Next technical report · OfficeChai: Alibaba Releases Qwen 3.8 Flash-Next · PC Watch (Japanese)

Originally published at: Qwen3.8-Flash-Next (2026): The Complete Guide to Qwen's Qwen4-Preview Architecture Model

Gesture Synth Weld Vercel App 2026: How a Webcam Becomes a Synthesizer

cz — Sun, 16 Aug 2026 14:06:00 +0000

Gesture Synth Weld Vercel App 2026: How a Webcam Becomes a Synthesizer

🎯 Core Takeaways (TL;DR)

The weld vercel app that took the web by storm is Gesture Synth — a browser-based musical instrument at gesture-synth-weld.vercel.app that turns your webcam into a real-time synthesizer using hand gestures, with zero downloads and zero installs.
Under the hood, the synth weld vercel app runs MediaPipe Hand Landmarker (two hands, 21 landmarks each) to classify finger patterns into chords, while a Web Audio API signal chain — oscillators → wave shaper → biquad filter → master gain — produces the sound entirely in the browser.
The gesture vocabulary is musical, not arbitrary: the left hand picks the chord degree (I–VII via finger counts and 🤘/🤟 shapes), the right hand controls voicing and expression, and hand tilt sweeps the filter from acoustic warmth to EDM squelch.
The gesture synth engine maps every hand state to a deterministic musical result: finger count → Roman numeral, middle-MCP position → major/minor quality, wrist tilt → filter frequency and resonance, with smooth setTargetAtTime transitions that eliminate audio clicks.
The gesture synth weld vercel project is open source (88+ stars on GitHub), built with Vite, and free for educational and non-commercial use — a perfect case study for anyone exploring the gesture synth weld vercel app pattern of camera + Web Audio.

What Is the Weld Vercel App?
Why Gesture Synth Went Viral
How the Gesture Synth Tracks Your Hands
The Synth Engine: Web Audio API Signal Chain
Gesture-to-Chord Mapping
Filter Sweeps and Expression
The Three Synth Presets
Performance and Browser Constraints
FAQ
Conclusion

What Is the Weld Vercel App?

The weld vercel app in question is Gesture Synth, a camera-based musical instrument created by Eric Wei and deployed at gesture-synth-weld.vercel.app. Open the URL, click to enable audio and grant camera access, and your hands become a synthesizer: move them in front of the webcam to change chords, sweep filters, and shape distortion in real time. There is no download, no account, and no MIDI controller — just a browser, a webcam, and the gesture synth engine running entirely client-side.

The name comes from the deployment slug: the synth weld vercel app is the "weld" of "gesture-synth" and "weld" in the Vercel project URL. For SEO purposes, the gesture synth weld vercel combination is what people actually search for when they see the app on social media and want to find it again — which is why this guide covers the full keyword family: gesture synth weld vercel app, gesture synth weld, and the primary weld vercel app phrase.

The app itself is deceptively simple on the surface. A dark stage fills the screen, your webcam feed is processed invisibly, and a chord display shows what you are playing. Twelve keys (A through G#/Ab) let you pick a root, three synth presets change the character of the sound, and a filter control shows the current sweep position. But underneath, the gesture synth is a carefully engineered pipeline of hand tracking, gesture classification, and Web Audio synthesis — and that is what this article dissects.

💡 Professional Tip: The weld vercel app pattern — a single-page Vite app deployed on Vercel with MediaPipe and Web Audio — is a template you can reuse for your own camera-based tools. The entire implementation is open source on GitHub (ericwei97-cloud/gesture-synth).

Why Gesture Synth Went Viral

The gesture synth weld vercel app went viral for a simple reason: it is a demo you can understand in five seconds and play for an hour. The Instagram tutorial posted by the creator shows exactly how it works — left hand picks the chord, right hand shapes the sound — and the immediacy of "your webcam is now a synthesizer" is the kind of moment people share.

There is also a deeper pattern at work. The gesture interaction model removes the last barrier between a person and an instrument: no keyboard, no mouse, no touchscreen. You move your body and music comes out. That is the same reason the gesture synth genre keeps producing viral hits — from gesture-controlled theremins to hand-tracking drum machines — and why the synth weld vercel app deployment model (free hosting, instant load, no install) is the perfect vehicle for it.

For developers, the viral moment matters less than the architecture. The gesture synth weld vercel project demonstrates that a production-quality musical instrument can run entirely in the browser: MediaPipe's Hand Landmarker delivers 21 landmarks per hand at interactive frame rates, and the Web Audio API synthesizes chords with sub-millisecond scheduling. No server, no native code, no app store. That is the gesture synth weld vercel app lesson: the browser is now a musical instrument platform.

How the Gesture Synth Tracks Your Hands

The gesture synth uses MediaPipe Hand Landmarker from @mediapipe/tasks-vision (v0.10.35), configured with numHands: 2 and a 640×480 video input. Each hand is reduced to 21 landmarks — wrist, four finger MCP/PIP/DIP joints, and fingertips — and the gesture synth logic reads those landmarks to classify what your hand is doing.

The classification functions in the source are precise and readable:

isThumbExtended() compares the thumb tip's x-coordinate to the thumb IP joint, with handedness-aware direction (a right-hand thumb extends to the right, a left-hand thumb to the left).
isFingerExtended() checks each finger's extension state.
getChordQuality() compares the middle finger MCP joint to the wrist: if the MCP is to the right of the wrist, the chord is minor; otherwise major. This is the gesture that flips a chord's mood.
classifyChord() combines the five finger states into a Roman numeral: one finger → I, two → II, three → III, four → IV, five → V, and the index+pinky shapes (🤘 and 🤟) → VI and VII.

The result is a deterministic mapping from hand shape to scale degree. Because the gesture synth reads raw landmark positions rather than relying on a gesture classifier model, the logic is transparent, debuggable, and fast — every frame produces a decision with no ambiguity.

The Synth Engine: Web Audio API Signal Chain

The sound of the gesture synth weld vercel app comes from a classic Web Audio API signal chain, built lazily on first user interaction (browsers require a user gesture before audio can start):

oscillators → waveShaper (distortion) → biquadFilter (lowpass) → masterGain → destination

The SynthEngine class in the source creates the chain in ensureContext():

WaveShaperNode with oversample: "4x" — the distortion stage, with 4× oversampling to reduce aliasing harshness.
BiquadFilterNode — a lowpass filter, base frequency 1200 Hz, Q 0.7.
GainNode — the master volume, starting at 0 and ramped smoothly.

When a chord is played, playNotes() stops the previous oscillators and creates one OscillatorNode per note frequency, connecting each to the wave shaper. The current chord is deduplicated by its frequency key, so repeated frames do not restart the sound. Volume changes use setTargetAtTime with a 0.03 time constant, and filter changes use 0.04 — the gesture synth deliberately smooths every audio parameter update to eliminate the clicks and zipper noise that plague naive Web Audio implementations.

Gesture-to-Chord Mapping

The musical core of the gesture synth is the mapping from hand state to chord. The left hand selects the scale degree, and the right hand selects the voicing and expression. The scale is built from semitone offsets in a major scale, and the chord quality (major/minor) comes from the middle-MCP-vs-wrist gesture described above.

Fingers Extended	Gesture	Scale Degree	Chord
1	1️⃣	I	Root chord
2	2️⃣	II	Second degree
3	3️⃣	III	Third degree
4	4️⃣	IV	Fourth degree
5	5️⃣	V	Fifth degree
Index + pinky	🤘	VI	Sixth degree
Index + pinky + thumb	🤟	VII	Seventh degree

The right hand adds voicing variations: four finger configurations produce major, minor, dominant, and diminished voicings — the diminished case even uses a tritone (diminished fifth) for the Diminished 7th chord, a detail that shows the gesture synth author thought carefully about music theory, not just hand tracking. The left hand's tilt mode switches the whole scale between major and minor, so the same gesture vocabulary produces very different music depending on context.

Filter Sweeps and Expression

The most expressive control in the gesture synth weld vercel app is the filter sweep, driven by hand tilt. getHandHorizontalTilt() computes the wrist's position relative to the middle and ring finger MCP knuckles, with a dead zone in the middle and a MAX_TRAVEL of 0.12 before the tilt saturates at ±1.0.

The tilt then drives the filter in two directions:

Inward tilt (negative): the filter frequency drops from 1200 Hz down to 250 Hz, and Q rises to 2.2 — an acoustic, woody warmth.
Outward tilt (positive): the filter frequency rises to 5000 Hz and Q spikes to 5.2 — a resonant, synthetic "squelch" straight out of EDM.

The gesture synth also uses tilt shakiness to drive a jitter effect: random noise is scaled by how much the right hand is shaking, turning nervous energy into audible texture. And the on-screen energy visualization colors the display by chord — major chords glow at full opacity, minor chords damp to a moody 45% — so the visual feedback matches the musical mood.

The Three Synth Presets

The synth weld vercel app ships three oscillator presets that change the character of the sound:

Preset	Character	Waveform Family
Warm Synth	Soft, rounded, pad-like	Mellow waveforms
Bright Synth	Clear, cutting, lead-like	Brighter waveforms
Retro Synth	Classic, video-game feel	Square-ish, chiptune flavor

The preset selects the OscillatorNode waveform used by playNotes(), and because the rest of the chain (distortion, filter, gain) is shared, switching presets changes the timbre without breaking the gesture controls. This is a clean example of separating the control layer from the synthesis layer — the same hand gestures drive every preset.

Performance and Browser Constraints

A camera-based instrument has hard real-time constraints, and the gesture synth weld vercel app handles them with a few deliberate choices:

Client-side everything. MediaPipe runs in the browser via WebAssembly; no frames leave the device, which keeps latency low and privacy intact.
Cover-crop video. The app computes a "cover" crop rectangle in source-video pixel space, so the webcam feed fills the stage without distortion — a detail that matters for both visuals and landmark stability.
Frame-by-frame smoothing. Every audio parameter update uses setTargetAtTime or linearRampToValueAtTime, preventing clicks even when the filter sweeps at full speed.
Lazy audio context. The AudioContext is created only after the user clicks, satisfying browser autoplay policies and avoiding wasted resources.

The gesture synth also integrates Vercel Analytics and Speed Insights plus Microsoft Clarity, so the creator can watch how people actually play — a reminder that even a viral weld vercel app is a product with metrics.

FAQ

Q: What is the weld vercel app?

A: The weld vercel app is Gesture Synth, a browser-based musical instrument at gesture-synth-weld.vercel.app that uses your webcam and hand gestures to play real-time synthesizer chords, pads, and audio loops. The "weld" comes from the Vercel deployment slug of the gesture synth weld vercel app.

Q: How does the gesture synth work?

A: The gesture synth uses MediaPipe Hand Landmarker to track 21 landmarks per hand, classifies finger patterns into scale degrees (I–VII), and synthesizes chords with the Web Audio API. The left hand picks the chord, the right hand controls voicing and expression.

Q: Do I need to install anything to use the gesture synth weld vercel app?

A: No. The gesture synth weld vercel app runs entirely in the browser — no downloads, no accounts, no MIDI hardware. You only need a webcam and permission to use it.

Q: What gestures control the music?

A: Finger counts select scale degrees (1–5 fingers → I–V, 🤘 → VI, 🤟 → VII), the middle-finger position flips major/minor, and hand tilt sweeps the filter from warm to squelchy. The gesture vocabulary is shown in the in-app guide.

Q: Is the gesture synth open source?

A: Yes. The gesture synth weld vercel project is open source on GitHub (ericwei97-cloud/gesture-synth, 88+ stars), built with Vite, and free for educational and non-commercial use with credit to the original creator.

Q: Can I build my own synth weld vercel app?

A: Absolutely. The pattern is: MediaPipe Hand Landmarker for tracking, Web Audio API for synthesis, Vite for building, and Vercel for hosting. The gesture synth weld vercel app is a complete reference implementation to learn from.

Conclusion

The weld vercel app known as Gesture Synth is more than a viral demo — it is a complete, open-source case study in browser-based musical instruments. MediaPipe Hand Landmarker turns a webcam into a two-hand controller, a deterministic gesture vocabulary maps hand shapes to chords, and a carefully smoothed Web Audio API chain turns those chords into music without a single click or pop.

For developers, the takeaways are concrete. The gesture synth weld vercel app shows how to structure a real-time camera pipeline, how to map landmarks to musical decisions, and how to keep audio glitch-free under continuous control. The synth weld vercel app deployment model — free hosting, instant load, no install — is the reason the demo spread so fast, and the same pattern applies to any camera-based tool you want to ship.

If you have not tried it, open gesture-synth-weld.vercel.app, grant camera access, and play. Then read the source, fork it, and build your own gesture synth weld instrument — the browser is ready, and so is the gesture synth weld vercel app template.

Originally published at: Gesture Synth Weld Vercel App 2026: How a Webcam Becomes a Synthesizer

Qwen3.8-27B (2026): The Complete Guide to Qwen's New 27B Vision-Language Model

cz — Sat, 15 Aug 2026 12:18:38 +0000

Qwen3.8-27B (2026): The Complete Guide to Qwen's New 27B Vision-Language Model

🎯 Core Takeaways (TL;DR)

Qwen3.8-27B is the new 27-billion-parameter dense model from Alibaba's Qwen team — a native vision-language model that understands images and videos, with flexible thinking control and Apache 2.0 open weights.
The headline is agentic performance at local-model size: Qwen3.8-27B scores DeepSWE 1.1 at 42.2 (up from 13.3 for Qwen3.6-27B), Terminal Bench 2.1 at 73.0, and beats Claude Opus 4.6 Max on SWE-bench Pro, QwenSWEBench, LiveCodeBench v6, OSWorld, and AndroidWorld.
Qwen3.8-27B ships with a native 262,144-token context window (extensible to 1M via YaRN), 28B BF16 weights, thinking mode on by default, and reasoning_effort levels of xhigh/medium/low.
On OpenRouter, Qwen3.8-27B is available at $0.45 / $3.20 per million tokens — and Reddit users are already running it locally on RTX 3090s, dual RTX 5080s, and 16GB VRAM cards.

What Is Qwen3.8-27B?
Qwen3.8-27B Architecture & Specs
Qwen3.8-27B Benchmarks: The Agentic Leap
Qwen3.8-27B Pricing & API Access
Running Qwen3.8-27B Locally
Qwen3.8-27B vs the Competition
FAQ

What Is Qwen3.8-27B?

Qwen3.8-27B is the newest member of the Qwen3.8 generation — "the most capable generation in the Qwen open-model family to date," per the official model card. Built on the architectural foundation of Qwen3.5, Qwen3.8-27B delivers substantial gains across coding, professional work, research, and long-horizon agentic tasks, packed into a compact, deployment-friendly dense model.

The key word is dense. Unlike the giant Qwen3.8-Max (2.4T-parameter MoE) that grabbed headlines when its weights landed on August 8, 2026, Qwen3.8-27B is a 27B-parameter dense model designed to run on hardware individuals actually own. As the r/LocalLLaMA release thread put it, Qwen3.8-27B is a "renewal of the beloved Qwen model, delivering unmatched intelligence density."

Qwen3.8-27B is also a native vision-language model: it understands images and videos out of the box — from STEM diagrams and documents to hour-scale videos. It's the first Qwen model in this class with full multimodal input and the flexible thinking control that the community has wanted since the GPT-OSS era: "FINALLY! I waited since GPT-OSS for other local model that natively has low and medium reasoning! High for planning, low for execution and exploration," one Redditor wrote.

💡 Professional Tip: Qwen3.8-27B is hosted on Hugging Face at Qwen/Qwen3.8-27B (9.47K likes, ~92K downloads/month, 319 quantization variants) and ModelScope. A hosted version on Qwen Cloud is coming soon with 1M context by default and built-in tools.

Qwen3.8-27B Architecture & Specs

Here's what's under the hood of Qwen3.8-27B:

Spec	Qwen3.8-27B
Model type	Causal LM with vision encoder
Parameters	27B (BF16, ~28B weights on disk)
Hidden dimension	5,120
Layers	64
Hidden layout	16 × (3 × (Gated DeltaNet → FFN) → 1 × (Gated Attention → FFN))
Linear attention heads	48 V / 16 QK (Gated DeltaNet), dim 128
Attention heads	24 Q / 4 KV (Gated Attention), dim 256
FFN intermediate dim	17,408
Multi-token prediction	Trained with multiple steps
Native context	262,144 tokens
Extensible context	Up to 1,000,000 tokens (YaRN)
License	Apache 2.0
Inputs	Text, image, video
Outputs	Text

The hybrid architecture combines Gated DeltaNet (linear attention for cheap long-context processing) with Gated Attention layers, plus multi-token prediction (MTP) for faster decoding. Qwen3.8-27B supports thinking mode on by default, with reasoning_effort tunable between xhigh (default), medium, and low, and preserve_thinking retaining reasoning context across turns — a design that the model card says "improves KV cache utilization, optimizing inference efficiency in both thinking and non-thinking modes."

For ultra-long work beyond 262K tokens, Qwen3.8-27B recommends YaRN RoPE scaling with a factor of 4.0 (or 2.0 if your typical context is ~524K) — supported in vLLM, SGLang, and TokenSpeed.

✅ Best Practice: For agentic tasks on Qwen3.8-27B, allocate generous output lengths: up to 262,144 tokens for reasoning content and 131,072 for the final response. Lower reasoning_effort doesn't always reduce total task time — insufficient analysis leads to more retries.

Qwen3.8-27B Benchmarks: The Agentic Leap

The reason Qwen3.8-27B broke the r/LocalLLaMA release thread with comments like "That DeepSWE leap — do we have a new local coder champion?" is the sheer size of its gains over the previous generation. Here are the official text benchmarks (Claude Code harness where noted):

Benchmark	Qwen3.8-27B	Qwen3.6-27B	Qwen3.7-Plus	Opus 4.6 Max
Terminal Bench 2.1 (Terminus)	73.0	63.4	64.0	78.2
SWE-bench Pro	61.7	53.5	57.6	53.4
NL2Repo-Bench	42.3	36.2	41.1	47.6
DeepSWE 1.1	42.2	13.3	14.2	–
QwenSWEBench	79.0	49.3	59.2	63.8
CoWorkBench	70.7	61.0	65.1	68.2
JobBench	33.4	21.8	27.6	–
Agents' Last Exam (score)	42.9	27.3	33.6	–
IFBench	79.5	69.1	79.1	62.5
GPQA Diamond	89.2	87.8	90.3	91.3
HLE	30.8	24.0	34.7	40.0
LiveCodeBench v6	90.3	83.9	89.6	88.8

The DeepSWE number is the standout: Qwen3.8-27B more than tripled its predecessor's score (13.3 → 42.2) and outperformed Opus 4.6 Max on SWE-bench Pro, QwenSWEBench, CoWorkBench, and LiveCodeBench v6 — despite being a fraction of the size. Independent leaderboards are already matching the model card: datacurve's DeepSWE leaderboard lists Qwen3.8-27B at 42.2 and ScaleAI's SWE-bench Pro at 61.7.

Where Qwen3.8-27B truly separates from other local models is multimodal agents:

VL Benchmark	Qwen3.8-27B	Qwen3.6-27B	Opus 4.6 Max
OSWorld-Verified (computer use)	84.3	63.9	72.7
WebArena-Verified (browser)	64.8	48.8	–
AndroidWorld (mobile)	81.9	70.3	62.0
RecreationBench	47.1	29.8	–
ClawEval-MM (Pass@3)	57.4	42.6	52.5
SWE-MM	38.6	25.7	27.1
Vision2Web	62.9	45.0	–
MathVision (with CI)	94.6	85.1	65.5
CharXiv (with CI)	90.2	78.4	85.9
OmniDocBench 1.5	91.1	89.4	86.6
RealWorldQA	85.9	84.1	73.9
ERQA	65.5	62.5	40.8

Qwen3.8-27B beats Opus 4.6 Max on OSWorld, AndroidWorld, SWE-MM, MathVision, CharXiv, OmniDocBench, RealWorldQA, and ERQA — computer use, mobile use, document intelligence, and embodied perception, all in a model that fits on consumer GPUs.

Qwen3.8-27B Pricing & API Access

Qwen3.8-27B is live on OpenRouter as qwen/qwen3.8-27b:

Pricing Metric	Qwen3.8-27B
Input / 1M tokens	$0.45 (weighted avg $0.4499)
Output / 1M tokens	$3.20 (weighted avg $3.199)
Context window	262K
Released on OpenRouter	Aug 14, 2026
Provider	AkashML (single)
Throughput	18 tok/s (P50)
Latency	1.50s (P50)
Uptime (3d)	91.97%
Availability (3d)	79.65%
Tool call error rate	1.06%
Structured output error rate	17.52%

Early production traffic tells the story: Qwen3.8-27B's top apps on OpenRouter are Kilo Code (7.98M tokens), Zed Editor (7.02M), pi (4.82M), and Hermes Agent (4.5M) — all agentic coding tools. At $0.45/$3.20, Qwen3.8-27B undercuts most frontier APIs by an order of magnitude while handling tool calls, structured outputs, images, and video.

For API usage, Qwen3.8-27B follows the standard Qwen3.8 pattern: thinking mode on by default (enable_thinking: True), reasoning_effort of xhigh/medium/low, and preserve_thinking: True by default. Recommended sampling: thinking mode at temperature 1.0 / top_p 0.95; instruct mode at 0.7 / 0.8 with presence_penalty 1.5.

⚠️ Attention: OpenRouter currently routes Qwen3.8-27B through a single provider (AkashML) with 79.65% availability over 3 days and a 17.52% structured-output error rate. For production reliability, wait for Qwen Cloud's hosted version or self-host.

Running Qwen3.8-27B Locally

This is where Qwen3.8-27B shines brightest — "RTX 3090 fans: ENGAGE" was the top comment on the release thread. Community reports:

Dual RTX 5080 (32GB total): user n0head_r ran the unsloth Qwen38-27B-Q6_K GGUF with 172K context (kv q8_0), MTP + tensor-split at a stable ~100 tps until 60–70K context (~95 tps at 100K). A 150K-token agent loop — writing, building, verifying, fixing errors — completed with zero failed tool calls.
RTX 4080 16GB: on r/ollama, Qwen3.8-27B ran at 12.6GB VRAM / 5.6GB CPU with an 8K context, completing a 2-tool agentic task (math eval + live crypto price, both correct) in ~18s.
RTX 3090 24GB: expected to be the sweet spot for Q4/Q6 quantizations, with Q8_0 also reported working via unsloth.

Deployment options for Qwen3.8-27B:

Hugging Face Transformers — AutoModelForMultimodalLM.from_pretrained("Qwen/Qwen3.8-27B")
vLLM / SGLang / TokenSpeed — vllm serve "Qwen/Qwen3.8-27B" for OpenAI-compatible serving
llama.cpp / Ollama / LM Studio — via the 319 community quantizations (Q4_K_M, Q6_K, Q8_0, etc.)
Docker Model Runner — docker model run hf.co/Qwen/Qwen3.8-27B

✅ Best Practice: If you're on a single 16–24GB GPU, grab a Q4 or Q6 GGUF of Qwen3.8-27B from unsloth; with 32GB+ VRAM or dual cards, Q8_0 with tensor splitting and MTP gives the best speed/quality balance.

Qwen3.8-27B vs the Competition

How does Qwen3.8-27B stack up against the models it's being compared to?

Model	Size	DeepSWE	Terminal Bench	Local-friendly	Vision
Qwen3.8-27B	27B dense	42.2	73.0	✅ (16GB+ VRAM)	✅ image+video
DeepSeek V4 Flash 0731	284B A13B	54.4	82.7	⚠️ (big)	❌
Qwen3.6-27B	27B dense	13.3	63.4	✅	✅
Opus 4.6 Max	frontier	–	78.2	❌	✅
Minimax M2.7	MoE	–	–	⚠️	❌

Reddit's read: "at 27B parameters, Qwen3.8-27B is pretty close to DeepSeek V4 Flash 0731 which is 284B A13B!" — while others noted "It seems better than 900+B MoE" and asked whether Qwen3.8-27B beats Minimax M2.7 in agentic coding. The verdict so far: Qwen3.8-27B offers frontier-adjacent agentic and multimodal performance at a fraction of the parameter count, and it's the strongest local coder candidate since the 27B class began.

🤔 FAQ: Qwen3.8-27B

Q: What is Qwen3.8-27B?

A: Qwen3.8-27B is Alibaba Qwen's 27-billion-parameter dense vision-language model, released as open weights under Apache 2.0 in August 2026. It understands images and videos, supports flexible thinking control, and targets coding, professional work, research, and long-horizon agentic tasks.

Q: How much does Qwen3.8-27B cost?

A: On OpenRouter, Qwen3.8-27B costs $0.45 per million input tokens and $3.20 per million output tokens. It's also free to self-host under Apache 2.0, and a Qwen Cloud hosted version with 1M context is coming soon.

Q: What is the context length of Qwen3.8-27B?

A: Qwen3.8-27B natively supports 262,144 tokens (262K), extensible to 1,000,000 tokens via YaRN RoPE scaling in vLLM, SGLang, or TokenSpeed.

Q: Does Qwen3.8-27B support images and video?

A: Yes. Qwen3.8-27B is a native vision-language model with image and video input — from STEM diagrams and documents to hour-scale videos — plus computer-use and browser-use capabilities (OSWorld-Verified 84.3, WebArena-Verified 64.8).

Q: Can I run Qwen3.8-27B locally?

A: Yes. Qwen3.8-27B runs on consumer GPUs: reported setups include RTX 3090 24GB, dual RTX 5080s (Q6_K at ~100 tps with 172K context), and RTX 4080 16GB (12.6GB VRAM via Ollama). 319 quantization variants are available.

Q: Does Qwen3.8-27B support tool calling and structured outputs?

A: Yes. Qwen3.8-27B supports tool calling, JSON output, and the OpenAI-compatible Chat Completions API, and it's already used in production by Kilo Code, Zed, pi, and Hermes Agent via OpenRouter.

Q: Is Qwen3.8-27B open source?

A: Qwen3.8-27B ships under the Apache 2.0 license — fully open weights, commercial use allowed. It's available on Hugging Face (Qwen/Qwen3.8-27B) and ModelScope.

Q: When was Qwen3.8-27B released?

A: Qwen3.8-27B was released on August 14, 2026 (open weights on Hugging Face and ModelScope, plus same-day availability on OpenRouter), following Qwen's announcement alongside Qwen3.8-Max.

Q: How does Qwen3.8-27B compare to Qwen3.6-27B?

A: Qwen3.8-27B roughly triples DeepSWE (13.3 → 42.2), gains ~10 points on Terminal Bench (63.4 → 73.0), +8.2 on SWE-bench Pro, and +20 on OSWorld (63.9 → 84.3) versus Qwen3.6-27B — a full generation's worth of progress.

Summary & Recommended Actions

Qwen3.8-27B is the model the local-AI community has been waiting for: frontier-adjacent agentic performance — DeepSWE 42.2, SWE-bench Pro 61.7, OSWorld 84.3, LiveCodeBench v6 90.3 — in a 27B dense package that runs on a single 24GB GPU, beats Opus 4.6 Max on multiple benchmarks, and costs $0.45/$3.20 per million tokens on OpenRouter. It has vision (image + video), flexible thinking control, 262K native context, and Apache 2.0 licensing.

The caveats: benchmarks are Qwen's own until independently verified, the single AkashML provider on OpenRouter has 79.65% availability, and structured-output reliability (17.52% error rate) needs watching. But as one commenter put it: "At this rate next year maybe we won't need AI-aaS companies."

Your next steps:

Try the API — test Qwen3.8-27B on OpenRouter for an agentic coding task and compare against your current model.
Download a GGUF — grab a Q4/Q6_K quantization of Qwen3.8-27B from unsloth and try it on your local GPU today.
Watch for Qwen Cloud — the hosted Qwen3.8-27B with 1M context and built-in tools is coming soon; keep an eye on Hugging Face for updates.

Sources: Qwen3.8-27B on Hugging Face · r/LocalLLaMA release thread · Qwen3.8-27B on OpenRouter · Qwen3.8-Max blog · r/ollama benchmarks · Medium: the most important local AI release of 2026

Originally published at: Qwen3.8-27B (2026): The Complete Guide to Qwen's New 27B Vision-Language Model

DeepSeek Harness Agent Loop 2026: Inside the Replaceable Plugin That Drives Every Turn

cz — Fri, 14 Aug 2026 11:26:37 +0000

DeepSeek Harness Agent Loop 2026: Inside the Replaceable Plugin That Drives Every Turn

🎯 Core Takeaways (TL;DR)

The DeepSeek Harness agent loop is itself a replaceable plugin: packages/core/agent-loop ships ReactLoopAgent as the default implementation of the Agent interface defined by core/agent — other plugins depend only on the interface, never on the loop, so the whole loop can be swapped out.
The DeepSeek Harness agent loop operates on two levels: a turn (zero or more steps, opened when the first input arrives and closed when the model owes nothing) and a step (one model request plus the tools it calls). Model-visible history is never stored separately — it is projected from the append-only session log via deriveMessages().
A phase state machine (idle | maintenance | running) gates the driver, and every boundary — turn/start, step/start, user/message, assistant/chunk, tool/call, tool/result, step/end, turn/end — is written to the durable session log, so fork, resume, replay, and telemetry all derive from one event stream.
Four extension points make the DeepSeek Harness agent loop interceptable without modification: agent/pre-step (waterfall), agent/request (waterfall), agent/request-error (waterfall), and agent/turn-stopping (serial). Tool execution runs through a three-stage pipeline: tools/pre-execute → tools/execute → tools/post-execute.
If you are building plugins for the DeepSeek Harness agent loop, the DSH Plugins directory is the place to discover, list, and share them with the ecosystem.

What Is the DeepSeek Harness Agent Loop?
Two Levels: Turns and Steps
The Phase State Machine
The Full Loop, Step by Step
Tool Execution: The Three-Stage Pipeline
Durable Events vs. Extension Points
Why a Replaceable Agent Loop Matters
The DSH Plugins Ecosystem
FAQ
Conclusion

What Is the DeepSeek Harness Agent Loop?

The DeepSeek Harness agent loop is the driver that keeps an agent working: it reads inputs, asks the model, executes tools, and decides when the agent owes the model another request. The defining fact about it — and the reason it deserves a deep dive — is that the loop itself is a plugin.

In packages/core/agent-loop, the default implementation is ReactLoopAgent, which implements the Agent interface defined by core/agent. Other plugins depend only on that interface, never on the concrete loop class. That single architectural decision means the DeepSeek Harness agent loop can be replaced wholesale: mount a different plugin that implements Agent, and every consumer keeps working. The interface is the contract; the loop is the implementation; the harness is the composition.

This is consistent with the broader "everything is a plugin" philosophy of DeepSeek Harness, which we covered in our earlier guide. The agent loop is not a privileged core component — it is one plugin among many, and it participates in the same event system as everything else.

💡 Professional Tip: When you read the code, start from the Agent interface in core/agent before reading ReactLoopAgent. Everything the loop does is a response to that contract, and the interface is what your own loop plugin must satisfy.

Two Levels: Turns and Steps

The DeepSeek Harness agent loop organizes work into two nested levels: turns and steps.

A turn is zero or more steps. It opens when the first input arrives and closes when the loop "no longer owes the model anything" — that is, when there is no pending input and no tool result that requires another model request.
A step is one model request plus the tools it calls. Each step is a single round trip through the model, followed by whatever tool calls the model requested.

The model-visible history is not stored separately. Instead, it is projected from the append-only session log by deriveMessages(). Everything the model can see must be reconstructible from the log — this is a hard invariant of the architecture, documented in docs/architecture.md. The practical consequence: the session log is the single source of truth, and the model's context window is always a derived view of it.

Level	Definition	Boundary Events
Turn	Zero or more steps; opened by first input, closed when the model owes nothing	`turn/start`, `turn/end`
Step	One model request + the tools it calls	`step/start`, `step/end`
Message	A user or assistant message within a step	`user/message`, `assistant/message`

The Phase State Machine

The driver of the DeepSeek Harness agent loop is gated by a small state machine: Phase = idle | maintenance | running.

idle — no driver is running; the agent is waiting for input.
maintenance — a transient state used while the driver is being torn down or prepared.
running — the driver is active across the entire drain interval, which can span multiple consecutive turns.

State transitions emit agent/status events, so any plugin can observe the loop's lifecycle without touching it. This is a recurring pattern in the DeepSeek Harness agent loop: state changes are events, and events are the extension surface.

The Full Loop, Step by Step

Here is the complete flow of the DeepSeek Harness agent loop, mapped to the actual code in packages/core/agent-loop/src/agent.ts.

Step 0: Wake and drive

Inputs enter through send, followup, steer, or inject, which push messages into the Inbox's two ordered queues (next-turn and next-step). followup and steer also wake the driver.

wakeDriver() — when idle, it claims a running phase (fresh AbortController, turn = previous turn, step = 0) and runs kick() inside ctx.agents.withInitiator(this, …).
kick() — while (await this.turn()) {}: as long as there is pending input, a new turn is opened.

Step 1: Open a turn

turn() first appends turn/start to the session — the durable open boundary. Then it loops over steps.

Step 2: Pre-step — claim input and interception decision

preStep() does three things:

inbox.claim(target, turn) — claims the input batch for this step (all next-step messages, plus one next-turn message at turn boundaries). Claiming is a pure splice-delete; each claimed message emits agent/inbox/claimed.
ctx.systemPrompt.assemble(...) — assembles the prompt sections and tool schema.
dispatch.waterfall('agent/pre-step', …) — the first extension point. Listeners can reject (no step opens; the turn ends as blocked) or enter and rewrite the message batch; the default enter uses the claimed messages. The result is { reject } or { enter, messages, assembly }.

💡 Special case: if the first step is rewritten to empty, the turn still occupies its boundary but does not spend a model call — it ends as completed.

Step 3: Open a step and persist user messages

session.append('step/start', { turn, step }) — durable.
Each message in decision.messages is appended as user/message — durable. Claimed inputs become durable user messages only at this point.

Step 4: Build the request, stream, assemble, call tools

step() runs an inner loop (which supports retries):

4a. Build the request — buildRequest():

dispatch.waterfall('agent/request', …) — the second extension point. Listeners can replace the frozen call configuration (provider, model, reasoningEffort, maxTokens); the default uses agent options or the recorded header.
ctx.llm.prepareCall(config, signal) — binds to the concrete adapter and materializes exact-model defaults.
session.append('request/header', …) and request/context (only when it changes) — durable, so the log can rebuild the request.
The frozen request is assembled: config + deriveMessages() history + system + tools + sessionId + signal.

4b. Stream:

preparedCall.stream(request) ?? ctx.llm.stream(request) — send the request and read the stream.
for await chunk — each chunk is appended as assistant/chunk (durable, preserving raw stream fidelity for replay and UI) and fed to the BlockAssembler.

4c. Finish dispatch — assembler.finish:

error / aborted → dispatch.waterfall('agent/request-error', …) — the third extension point. A listener returning { kind: 'retry' } (without calling next) retries the step; the default undefined lets the failure terminate (throwing LlmError).
max-tokens → append assistant/message, return { kind: 'max-tokens' }.
Normal → append assistant/message with { turn, step, message, usage } and sourceEventSeqs referencing the corresponding chunks — durable.

4d. Tool calls:

Filter tool-call blocks from the assistant message. None → return { kind: 'completed' } (the step ends; the model owes nothing).
Some → executeToolCalls(...) in tool-calls.ts.

Step 5: Close the step, decide whether to open another

finally: session.append('step/end', { turn, step }) — durable.
If the step produced a terminal result (turnEnds is non-null) and the inbox has no next-step input:
- dispatch.serial('agent/turn-stopping', { turn, signal }) — the fourth extension point (serial, no next). A listener that objects calls agent.steer(...) to inject steering; the machine re-reads the inbox and opens another step. If nobody objects, the turn closes.
If there is next-step input → target = 'next-step', back to step 2 for another step (tool continuation).

Step 6: Close the turn, decide whether to open another

finally: session.append('turn/end', { turn, reason: turnEnds }) — durable. reason is one of completed / max-tokens / blocked / aborted / error.
If the inbox still has pending input → reset the AbortController, step = 0, return true (open a new turn). Otherwise → back to idle.

Tool Execution: The Three-Stage Pipeline

Tool scheduling in the DeepSeek Harness agent loop groups calls by execution mode: mutually exclusive calls are a barrier, parallel calls use a bounded rolling pool (maxParallelToolCalls). Each call runs through a three-stage pipeline, with events mounted on the ctx.tools scheduler — the attachment point for policy, timeouts, and observability:

tools/pre-execute → tools/execute → tools/post-execute

prepare (pre-execute) may short-circuit into a direct result.
dispatch (execute) runs the tool.
finalize / finish (post-execute) wrap up.

Two details are worth calling out. First, results are committed in model order (commitReady advances across consecutive slots), not in completion order — the model's view of the world stays consistent. Second, tool/call is appended before dispatch (durable), and tool/result is appended after post-execute (durable, referencing the corresponding call seq). A result's additionalContexts go into the next-step inbox and become the context for the next step boundary; a result with concludesTurn ends the turn early.

The return value is { concluded }: concluded → { kind: 'completed' }; otherwise null is returned, meaning the tools still owe the model a request — back to 4a for another round.

Durable Events vs. Extension Points

The whole design of the DeepSeek Harness agent loop can be summarized in one diagram: durable events (the record) versus extension points (the seams).

turn/start (durable)
  claim inbox + assemble prompt
  ─ agent/pre-step (waterfall) reject | enter(messages) ─
  step/start (durable)
  user/message* (durable)
  ─ agent/request (waterfall) swap config ─
  llm/stream → assistant/chunk* (durable) → assistant/message (durable)
  tool/call* (durable) → tools/pre-execute → tools/execute → tools/post-execute → tool/result* (durable)
  ─ agent/request-error (waterfall) retry on failure ─
  step/end (durable)
  tools still owe a request or next-step input → open another step
  ─ agent/turn-stopping (serial) close turn unless continued ─
turn/end (durable)

Extension Point	Kind	What a Plugin Can Do
`agent/pre-step`	waterfall	Reject the step, or enter and rewrite the message batch
`agent/request`	waterfall	Replace the frozen call config (provider, model, effort, tokens)
`agent/request-error`	waterfall	Return `{ kind: 'retry' }` to retry the failed step
`agent/turn-stopping`	serial	Object by steering; the loop re-reads the inbox and opens another step

The lines marked ─ ─ are extension points where plugins can hook in (waterfalls must call next() to pass through). Everything else marked (durable) is a persisted event written to the session log — fork, resume, transcription, and telemetry all derive from this one stream. The meaning of the design: swapping an adapter, adding policy, or intercepting requests, tools, and turns is a matter of mounting events or replacing a provider — never of modifying the loop itself.

Why a Replaceable Agent Loop Matters

The DeepSeek Harness agent loop being a plugin is not an implementation detail; it is the product. Three consequences follow:

No fork required. Teams that need a different loop behavior — a different retry policy, a different tool-scheduling strategy, a different turn-closing heuristic — write a plugin that implements Agent, rather than maintaining a fork of the harness.
Policy lives at the seams. Timeouts, approval gates, rate limits, and observability attach to the ctx.tools scheduler and the four extension points, not inside the loop's code.
The log is the contract. Because every model-visible artifact is reconstructible from the append-only session log, any loop implementation — default or custom — can be audited, replayed, and resumed through the same tooling.

✅ Best Practice: Before writing a custom loop, check whether your need is actually a policy that can be mounted on an existing extension point. The DeepSeek Harness agent loop is designed so that most customizations never touch the loop at all.

The DSH Plugins Ecosystem

Because the DeepSeek Harness agent loop and every other capability are plugins, the ecosystem around them matters as much as the core. The DSH Plugins directory is the community hub for discovering and listing plugins for DeepSeek Harness — including loop replacements, tool adapters, model providers, and policy plugins. If you are building for the DeepSeek Harness agent loop, listing your plugin there makes it discoverable to the wider community, and browsing it before you build can save you from reinventing an existing plugin.

FAQ

Q: Is the DeepSeek Harness agent loop really a plugin?

A: Yes. packages/core/agent-loop ships ReactLoopAgent as the default implementation of the Agent interface from core/agent. Other plugins depend only on the interface, so the entire loop can be replaced by mounting a different plugin.

Q: What is the difference between a turn and a step in the DeepSeek Harness agent loop?

A: A turn is zero or more steps, opened when the first input arrives and closed when the model owes nothing. A step is one model request plus the tools it calls. Turns and steps both have durable start/end events in the session log.

Q: Where does the model's history come from?

A: It is not stored separately. The DeepSeek Harness agent loop projects the model-visible history from the append-only session log via deriveMessages(). Everything the model can see must be reconstructible from the log.

Q: What extension points does the DeepSeek Harness agent loop expose?

A: Four: agent/pre-step (waterfall — reject or rewrite the input batch), agent/request (waterfall — replace the call config), agent/request-error (waterfall — retry on failure), and agent/turn-stopping (serial — object to closing the turn by steering).

Q: How are tool results ordered?

A: Results are committed in model order (commitReady advances across consecutive slots), not in completion order, so the model's view of the world stays consistent.

Q: Where can I find plugins for the DeepSeek Harness agent loop?

A: The DSH Plugins directory lists community plugins for DeepSeek Harness, including loop replacements, tool adapters, and policy plugins.

Conclusion

The DeepSeek Harness agent loop is a masterclass in replaceable architecture. By defining an Agent interface, shipping ReactLoopAgent as one implementation among many, persisting every boundary to an append-only log, and exposing four waterfall/serial extension points, the loop turns what is usually the most rigid part of an agent harness into the most flexible one.

The practical takeaway for developers: you do not need to understand the loop to use it, but understanding it unlocks the seams. Intercept a request at agent/request, retry a failure at agent/request-error, gate a turn at agent/turn-stopping, or replace the whole loop with your own Agent implementation. And when you build something worth sharing, the DSH Plugins directory is where the ecosystem finds it. The loop is the heart of DeepSeek Harness — and it is a heart you can transplant.

Originally published at: DeepSeek Harness Agent Loop 2026: Inside the Replaceable Plugin That Drives Every Turn

DeepSeek Harness 2026: Everything Is a Plugin — Developer Preview Guide

cz — Thu, 13 Aug 2026 13:24:49 +0000

DeepSeek Harness 2026: Everything Is a Plugin — Developer Preview Guide

🎯 Core Takeaways (TL;DR)

DeepSeek Harness (CLI name dsh) opened its v0.1 developer preview to the global harness developer community on August 13, 2026, with the full source released under the MIT license on GitHub.
The defining design principle of DeepSeek Harness is "everything is a plugin": models, tools, skills, sessions, sandboxes, storage, loops, scheduling, and UI are all Cordis plugins that can be freely swapped, replaced, and recombined — no source changes required.
DeepSeek Harness ships four run modes — Standard, PTC (Programmatic Tool Calling), Minimal, and Creation — each loading a different default plugin set for a different use case.
Every run of DeepSeek Harness is fully traceable: everything the model sees is written to an append-only session log, viewable by source in the Trajectory view, with resume, fork, retrieval, and replay all sharing the same event stream.
You can try DeepSeek Harness in under a minute: npx @deepseek-ai/dsh web starts the Web UI at http://127.0.0.1:3080.

What Is DeepSeek Harness?
The "Everything Is a Plugin" Philosophy
Four Run Modes of DeepSeek Harness
Append-Only Session Logs and the Trajectory View
Architecture: Profiles, Bundles, and Core Packages
How to Get Started with DeepSeek Harness
Building Plugins for DeepSeek Harness
DeepSeek Harness vs. Other Agent Harnesses
FAQ
Conclusion

What Is DeepSeek Harness?

DeepSeek Harness is an open-source agent harness developed by DeepSeek AI. It is the infrastructure layer that sits between a large language model and the tools, files, and environments an agent needs to get work done. Where many harnesses hard-code their components, DeepSeek Harness takes a radically different approach: every capability is a plugin, and the harness itself is just a composition of plugins.

On August 13, 2026, the DeepSeek Harness team announced the v0.1 developer preview, opening testing to harness developers worldwide and releasing the source code under the MIT license. The announcement, published on the team's official WeChat channel, was explicit that v0.1 is an early preview: many details are still being polished, and core plugins and base interfaces will iterate quickly in the coming releases. The team is inviting feedback from the global harness developer community as it builds out the DSH plugin ecosystem.

The project lives at github.com/deepseek-ai/deepseek-harness, is powered by the Cordis plugin framework, and is currently at version 0.1.0-rc.5 in its repository. The monorepo is organized into apps/ (the cli and web applications) and packages/ (core, llm, mcp, sandbox, context, plan, goal, and dozens more), which gives you a sense of the breadth of capabilities DeepSeek Harness composes out of the box.

💡 Professional Tip: Because DeepSeek Harness is in developer preview, expect compatibility-breaking changes. Pin the version you build against, and follow the GitHub repository for release notes before upgrading.

The "Everything Is a Plugin" Philosophy

The single most important idea in DeepSeek Harness is stated in its own documentation: everything is a plugin. The architecture is built on the Cordis plugin system, which is designed for spatiotemporal composability — a programming paradigm described in the Cordis paper, A Programming Paradigm for Spatiotemporal Composability.

Cordis acts as a meta-framework: it is responsible only for loading and unloading plugins and managing their dependencies. Every concrete component of DeepSeek Harness — the model adapter, the tool registry, the session log, the agent loop itself — is a different Cordis plugin. Plugins cooperate through Cordis services and typed events, and they can be freely combined at the configuration layer.

What this means in practice is that developers do not need to modify the source code of DeepSeek Harness to independently select, replace, or extend any of its capabilities. If you want a different model provider, you swap the model plugin. If you want a different sandbox, you swap the sandbox plugin. If you want a completely different agent loop, you mount your own. There is no privileged core to patch — you extend DeepSeek Harness by mounting a plugin beside the others, and registrations are effects that unwind cleanly when their plugin unloads.

✅ Best Practice: Treat every capability of DeepSeek Harness as replaceable. Before writing custom code, check whether a plugin already exists — the ecosystem is designed so that composition beats modification.

Four Run Modes of DeepSeek Harness

For different usage scenarios, DeepSeek Harness provides four modes, each of which loads a different default set of plugins:

Mode	What It Loads	Best For
Standard	A complete tool set	Everyday agentic work
PTC	Programmatic Tool Calling — the model generates one piece of code that composes multiple tool calls	Complex multi-step tool workflows
Minimal	Only one shell tool and one file-edit tool	Model benchmarking in minimal environments
Creation	Inspect the current runtime, experiment with Cordis plugins in memory, and compose new modes	Building and testing new plugin combinations

The PTC mode deserves special attention. Programmatic Tool Calling is a distinctive design in DeepSeek Harness: instead of the model making many individual tool calls, the model generates a single piece of code that orchestrates multiple tool calls in sequence. This reduces round trips, improves reliability, and gives the model a more expressive way to compose tools.

The Creation mode is equally interesting for plugin developers. It lets you inspect the running runtime, experiment with Cordis plugins in memory, and compose and create new modes from what you learn — a sandbox for designing the next configuration of DeepSeek Harness without restarting anything.

Append-Only Session Logs and the Trajectory View

One of the most developer-friendly features of DeepSeek Harness is its observability story. Every run is traceable: everything the model sees is written to an append-only session log, including system prompts, chain-of-thought, tool calls and their results, sub-agent scheduling, and every context injection.

In the Trajectory view, you can inspect all of this information by source. Because the log is append-only, nothing is ever silently rewritten — the record of what happened is preserved exactly as it occurred. Resume, fork, retrieval, and replay all share the same event stream, which means you can pick up a session where it left off, branch it into a new direction, search through its history, or replay it to understand what happened.

This design has practical consequences for debugging. When an agent run goes wrong, the session log of DeepSeek Harness shows you precisely what the model saw at every step — the exact system prompt, the exact tool output, the exact context injection. For teams building production agents, this level of traceability is the difference between guessing and knowing.

Architecture: Profiles, Bundles, and Core Packages

Under the hood, a running DeepSeek Harness is a plugin tree composed at boot from ordered layers. Two concepts organize this tree: profiles and bundles.

A profile is a named composition stored in the Harness home directory. It lists the bundles it stacks, holds any out-of-tree plugins it installs, and keeps the user's own cordis.patch.yml. The web and headless profiles ship as templates. A bundle is a distribution format for Cordis config rows and the code they mount, so whatever a bundle inserts stays patchable by the layers above it.

The base layer of every profile is dsh-base, which provides model adapters, tools, persistence, sandbox and approval policy, settings, credentials, and telemetry. dsh-web-app adds the browser application, and dsh-headless adds a one-shot runner with no server at all. You can inspect the exact tree your machine boots with:

dsh --profile web --dump-config

Any row printed by that command can be replaced by a patch of your own. The core packages of DeepSeek Harness map cleanly to responsibilities:

Package	Owns	`ctx` key
`core/session`	The append-only `SessionEvent` log and in-memory store	`ctx.sessions`
`core/system-prompt`	Prompt-section and tool-schema assembly	`ctx.systemPrompt`
`core/tools`	The scoped tool registry and guarded execution pipeline	`ctx.tools`
`core/agent`	The `Agent` interface, live registry, and `agent/*` events	`ctx.agents`
`core/agent-loop`	The default driver implementing that interface	`ctx.agentLoop`
`core/scope`	The per-agent scoped-registration primitive	library, no key

How to Get Started with DeepSeek Harness

Getting started with DeepSeek Harness takes minutes. The quickest path is the Web UI:

npx @deepseek-ai/dsh web

This command starts the Web UI, served at http://127.0.0.1:3080 by default. From there, the workflow is straightforward:

Configure a model: open Settings → Models, enter a DeepSeek API key, and save it. The model route becomes usable immediately without restarting the server. Other providers and custom OpenAI-compatible endpoints are supported via the model configuration guide.
Choose a workspace: click Choose workspace, add the project directory where you started dsh, and select it. The session composer stays unavailable until a workspace is selected.
Run a task: start a session and send a prompt. The agent can read and edit workspace files, run commands, delegate work, and maintain a plan. The Web UI asks before operations that require approval under the active permission policy.

If you prefer to run from source:

git clone https://github.com/deepseek-ai/deepseek-harness
cd deepseek-harness
pnpm install
pnpm run build
pnpm dsh web

The dsh process uses its invoking directory as the default filesystem location, and a fresh Web UI has no selected workspace until you add one. For headless automation, DeepSeek Harness also ships a one-shot runner profile with no server at all, plus a Python SDK for programmatic use.

⚠️ Attention: The dsh Web UI asks for approval before operations that require it under the active permission policy. Configure your permission policy deliberately before running untrusted tasks.

Building Plugins for DeepSeek Harness

Because everything in DeepSeek Harness is a plugin, plugin development is the primary extension path. The architecture documentation recommends starting with the Cordis primer and tutorial before writing plugins, since the framework's model of services, typed events, and reversible effects is the foundation of the whole system.

A plugin in DeepSeek Harness contributes services, typed events, and reversible effects to a shared context. When a plugin unloads, its registrations unwind — there is no orphaned state. Plugins are distributed as bundles, declared in package.json under a dsh field: dsh.profile lists a profile's bundles, and dsh.bundle points at a bundle's patch file.

The practical workflow for plugin authors is: experiment in Creation mode, where you can inspect the runtime and test Cordis plugins in memory; then package your plugin as a bundle; then mount it in a profile, either by editing cordis.patch.yml or by passing a --patch overlay. The --dump-config command shows you the exact rows your machine boots, so you always know what to patch.

The DeepSeek Harness team is explicitly courting the plugin ecosystem: the announcement invites global harness developers to co-build the DSH plugin ecosystem on open, reusable, composable infrastructure. If you build a plugin, you can add the dsh-plugin topic to your repository for discoverability.

DeepSeek Harness vs. Other Agent Harnesses

How does DeepSeek Harness compare to the agent harnesses most developers already know? The differences are mostly architectural:

Dimension	DeepSeek Harness	Typical Harness
Architecture	Everything is a plugin (Cordis)	Monolithic core + extensions
Extension path	Mount a plugin, no source changes	Fork or patch the core
Observability	Append-only session log + Trajectory view	Varies, often partial
Run modes	Standard / PTC / Minimal / Creation	Usually one mode
License	MIT, open source	Varies
Tool calling	Classic + PTC (code-composed calls)	Usually classic only

The most consequential difference is the plugin seam. In DeepSeek Harness, there is no privileged core to patch — every component, including the agent loop itself, is replaceable from configuration. For teams that have hit the limits of a harness's extension points, that is a meaningful difference. The append-only session log is also ahead of most alternatives, which typically log tool calls but not every context injection.

FAQ

Q: Is DeepSeek Harness free and open source?

A: Yes. DeepSeek Harness is released under the MIT license, and the full source is available at github.com/deepseek-ai/deepseek-harness. The v0.1 developer preview opened to the global community on August 13, 2026.

Q: How do I start DeepSeek Harness quickly?

A: Run npx @deepseek-ai/dsh web in a terminal with Node.js installed. The Web UI starts at http://127.0.0.1:3080. Then add a model API key in Settings → Models and choose a workspace.

Q: What does "everything is a plugin" mean in practice?

A: It means every capability of DeepSeek Harness — models, tools, skills, sessions, sandboxes, storage, loops, scheduling, UI — is a Cordis plugin. You can select, replace, or extend any of them without modifying the source code of DeepSeek Harness itself.

Q: What are the four modes of DeepSeek Harness?

A: Standard (complete tool set), PTC (programmatic tool calling, where the model writes code to compose tool calls), Minimal (one shell tool and one file-edit tool for benchmarking), and Creation (inspect the runtime and compose new modes in memory).

Q: Can I use DeepSeek Harness with models other than DeepSeek's?

A: Yes. The model configuration guide covers other providers and custom OpenAI-compatible endpoints. The model adapter is itself a plugin, so it is replaceable by design.

Q: Is DeepSeek Harness production-ready?

A: Not yet. v0.1 is an early developer preview with compatibility-breaking changes expected. It is ideal for experimentation, benchmarking, and plugin development, but teams should pin versions and follow the repository before relying on it in production.

Conclusion

DeepSeek Harness enters the agent infrastructure landscape with a bold bet: that the right architecture for agent harnesses is one where everything is a plugin. By building on Cordis, releasing under MIT, and shipping four run modes plus an append-only session log, the DeepSeek Harness team has given developers a harness that is open, observable, and composable to its core.

The v0.1 developer preview is explicitly a starting point, not a finish line. The team is inviting global harness developers to co-build the DSH plugin ecosystem on open, reusable, composable infrastructure, and the plugin-first design makes that invitation concrete: anyone can mount a plugin beside the others, no fork required.

If you build agents, the practical next step is simple. Clone the repository, run npx @deepseek-ai/dsh web, and spend an hour in Creation mode experimenting with plugins. Whether DeepSeek Harness becomes your production harness or just informs how you think about harness architecture, the everything-is-a-plugin design is worth studying — and it is now open for everyone to explore.

Originally published at: DeepSeek Harness 2026: Everything Is a Plugin — Developer Preview Guide

awesome design md (2026): The Complete Guide to Google's DESIGN.md Collection

cz — Thu, 13 Aug 2026 09:26:25 +0000

awesome design md (2026): The Complete Guide to Google's DESIGN.md Collection

🎯 Core Takeaways (TL;DR)

awesome design md is the fastest-growing community collection of DESIGN.md files on GitHub — VoltAgent's repository has surpassed 108,000 stars and ranks #105 globally on GitHub as of August 2026.
It ships 73 ready-to-use DESIGN.md files extracted from real websites like Stripe, Vercel, Linear, Figma, Tesla, and Spotify — drop one into your project, tell your AI agent "build me a page that looks like this," and get visually consistent UI.
Every entry in the awesome design md collection includes a full DESIGN.md plus preview.html and preview-dark.html, covering 9 sections from color tokens and typography to component states and responsive behavior.
awesome design md is built on the DESIGN.md standard that Google Stitch introduced and Google Labs open-sourced as a draft specification on April 21, 2026 — a plain-text markdown file that AI agents read to generate consistent UI.

What Is awesome design md?
What Is DESIGN.md and Why Does It Matter?
What's Inside the awesome design md Collection
How to Use awesome design md with AI Agents
Top Design Systems in awesome design md
How awesome design md Compares to Alternatives
FAQ

What Is awesome design md?

awesome design md is a curated GitHub repository by VoltAgent that collects DESIGN.md files analyzed from developer-focused websites. Its tagline is simple: copy a DESIGN.md into your project, tell your AI agent "build me a page that looks like this," and generate high-quality UI that stays visually consistent with the design language.

The repository — github.com/voltagent/awesome-design-md — describes itself as a "curated collection of DESIGN.md analysis by developer focused websites." Since launching in March 2026, awesome design md has grown to 108,000+ stars and a global GitHub rank of #105, making it one of the most-starred AI tooling repos of the year. It carries the official Awesome badge, a Discord community, and a sponsorship channel.

Why did awesome design md explode so fast? Because it fills a real gap: AI coding agents are great at writing code but bad at guessing your design language. awesome design md hands them the design system in the one format they read best — plain markdown.

💡 Professional Tip: The repo is MIT-licensed and every DESIGN.md inside is provided "as is" for generating consistent UI. The design tokens represent publicly visible CSS values — VoltAgent doesn't claim ownership of any brand's visual identity, so you can safely drop them into personal and commercial projects.

What Is DESIGN.md and Why Does It Matter?

To understand awesome design md, you first need to understand DESIGN.md. DESIGN.md is a new concept introduced by Google Stitch — a plain-text design system document that AI agents read to generate consistent UI. It's just a markdown file: no Figma exports, no JSON schemas, no special tooling. Drop it into your project root, and any AI coding agent or Google Stitch instantly understands how your UI should look.

The mental model pairs it with the AGENTS.md convention:

File	Who reads it	What it defines
`AGENTS.md`	Coding agents	How to build the project
`DESIGN.md`	Design agents	How the project should look and feel

On April 21, 2026, Google Labs open-sourced the draft specification of DESIGN.md, and the standard went mainstream — within days, the official spec repo crossed 10,000 stars while awesome design md surged past 68,000. Today awesome design md is widely cited — including in design tutorials from banani.co and design-bootcamp — as the single most popular resource for ready-made DESIGN.md files.

That's the entire point of awesome design md: instead of writing a design system from scratch, you borrow one that has already been extracted, analyzed, and structured by a team that cares about quality.

What's Inside the awesome design md Collection

awesome design md currently hosts 73 DESIGN.md files organized into 9 categories. Each entry follows the Stitch DESIGN.md format with extended sections:

#	Section	What it captures
1	Visual Theme & Atmosphere	Mood, density, design philosophy
2	Color Palette & Roles	Semantic name + hex + functional role
3	Typography Rules	Font families, full hierarchy table
4	Component Stylings	Buttons, cards, inputs, navigation with states
5	Layout Principles	Spacing scale, grid, whitespace philosophy
6	Depth & Elevation	Shadow system, surface hierarchy
7	Do's and Don'ts	Design guardrails and anti-patterns
8	Responsive Behavior	Breakpoints, touch targets, collapsing strategy
9	Agent Prompt Guide	Quick color reference, ready-to-use prompts

Each site in awesome design md ships three files:

File	Purpose
`DESIGN.md`	The design system (what agents read)
`preview.html`	Visual catalog: color swatches, type scale, buttons, cards
`preview-dark.html`	Same catalog with dark surfaces

The categories inside awesome design md span the full spectrum of modern web design: AI & LLM Platforms (Claude, Ollama, Mistral, xAI), Developer Tools & IDEs (Cursor, Vercel, Raycast, Warp), Backend & DevOps (Supabase, MongoDB, Sentry), Productivity & SaaS (Linear, Notion, Cal.com), Design & Creative (Figma, Framer, Webflow), Fintech & Crypto (Stripe, Coinbase, Binance), E-commerce (Shopify, Nike, Airbnb), Media & Consumer Tech (Apple, NVIDIA, Spotify), and even Automotive (Tesla, Ferrari, Bugatti).

awesome design md also has a delightfully quirky series: Retro Web · DESIGN.md Nostalgia. A Saturday series with period-accurate vintage UI — like Dell (1996) with "hand-cut GIF stickers" and Nintendo.com (2001) with "brushed-periwinkle beveled metal panels" — so you can tell your agent to build a time-capsule webpage.

✅ Best Practice: Not sure where to start with awesome design md? Pick a brand whose aesthetic you already admire — Vercel for black-and-white precision, Linear for ultra-minimal purple-accented UI, or Stripe for signature purple gradients. The design language you ship is the design language you live in.

How to Use awesome design md with AI Agents

Using awesome design md takes about two minutes:

graph TD
A[Browse awesome design md<br/>pick a site] --> B[Copy DESIGN.md<br/>into project root]
B --> C[Tell your AI agent<br/>'build a page like this']
C --> D[Agent reads tokens<br/>colors, type, components]
D --> E[Generate UI that matches<br/>the design language]

Browse the collection — open github.com/voltagent/awesome-design-md and pick a design system from the list (each links to a getdesign.md/<brand>/design-md page).
Copy the DESIGN.md into your project root, next to your AGENTS.md.
Prompt your agent — say "build me a landing page that matches the design in DESIGN.md," and Claude Code, OpenCode, Cursor, or any modern coding agent will follow the tokens and rules.
Iterate — use the Do's and Don'ts section of awesome design md files as guardrails, and check preview.html to see expected colors and type at a glance.

Community tutorials (including a popular YouTube walkthrough pairing awesome design md with OpenCode and Claude) confirm the workflow "is SO EASY & SO GOOD" — the hardest part is choosing which brand's aesthetic you want.

💡 Professional Tip: awesome design md maintainers accept requests at getdesign.md/request — you can request a DESIGN.md for a specific website, including private requests delivered exclusively to you. If your favorite brand isn't in the collection yet, that's the fastest way to fix it.

Top Design Systems in awesome design md

Here's a taste of what's inside awesome design md right now:

Brand	Category	Design language captured
Vercel	Dev tools	Black and white precision, Geist font
Linear	SaaS	Ultra-minimal, precise, purple accent
Stripe	Fintech	Signature purple gradients, weight-300 elegance
Claude	AI platforms	Warm terracotta accent, clean editorial layout
Figma	Design tools	Vibrant multi-color, playful yet professional
Supabase	Backend	Dark emerald theme, code-first
Shopify	E-commerce	Dark-first cinematic, neon green accent
Tesla	Automotive	Radical subtraction, cinematic photography
Spotify	Media	Vibrant green on dark, album-art-driven
Nintendo (2001)	Retro	Y2K console chrome, halftone-dotted carbon nav

Each of these entries took real work to produce — awesome design md isn't a list of links, it's a collection of deep design analysis. The repo's own description emphasizes "real design depth — including analyzed patterns, tokens, and rules — for high-quality UI generation, not surface-level outputs."

How awesome design md Compares to Alternatives

If you're evaluating awesome design md against the alternatives, here's the honest comparison:

Aspect	awesome design md	Write your own DESIGN.md	Design tokens from Figma
Time to first UI	Minutes	Hours to days	Requires tooling/exports
Depth of analysis	9 sections per file	Depends on your effort	Design tokens only, no rules
Brand aesthetics	73 real brands	Your own	Your own
Cost	Free (MIT)	Your time	Figma subscription
Agent readiness	Built for LLMs	Built for LLMs	Needs conversion

The gap awesome design md fills is the "starting point": it gives you a production-quality design system instantly, with previews, and lets you adapt it later. As one design-bootcamp analysis put it, "Google makes DESIGN.md open source on its way to becoming an industry standard" — and awesome design md is the community's biggest bet on that standard.

⚠️ Attention: DESIGN.md files in awesome design md replicate publicly visible CSS values of real brands. If you copy a brand's exact look for a client product, consider mixing palettes or renaming tokens so you build on the patterns rather than clone the brand.

🤔 FAQ: awesome design md

Q: What is awesome design md?

A: awesome design md is a GitHub repository by VoltAgent that curates DESIGN.md files extracted from 73 real websites — including Stripe, Vercel, Linear, Figma, and Tesla — so you can drop one into your project and have AI agents generate matching UI. It has over 108,000 stars.

Q: Where can I find awesome design md?

A: awesome design md lives at github.com/voltagent/awesome-design-md. Individual DESIGN.md files are hosted at getdesign.md (e.g., getdesign.md/stripe/design-md).

Q: Is awesome design md free to use?

A: Yes. awesome design md is MIT-licensed, and each included DESIGN.md is provided "as is" without warranty. You can use the files commercially, though the maintainers note the design tokens represent publicly visible CSS values and they don't claim ownership of any brand's identity.

Q: What is DESIGN.md?

A: DESIGN.md is a plain-text design system document introduced by Google Stitch and open-sourced as a draft specification by Google Labs on April 21, 2026. It's a markdown file that defines colors, typography, components, layout, and rules so AI agents can generate visually consistent UI. awesome design md is the biggest community collection of such files.

Q: How many DESIGN.md files are in awesome design md?

A: awesome design md currently contains 73 DESIGN.md files across 9 categories — from AI platforms and developer tools to fintech, e-commerce, automotive, and a retro 1990s series.

Q: What does each file in awesome design md include?

A: Each entry in awesome design md includes a DESIGN.md (design system with 9 sections: theme, colors, typography, components, layout, elevation, do's and don'ts, responsive behavior, and agent prompt guide) plus preview.html and preview-dark.html visual catalogs.

Q: How do I use awesome design md with my AI agent?

A: Copy a DESIGN.md from awesome design md into your project root, then prompt your agent with something like "build me a page that looks like this." Agents like Claude Code, Cursor, and OpenCode read the markdown directly — no conversion or tooling needed.

Q: Can I request a new DESIGN.md?

A: Yes — the awesome design md team accepts requests at getdesign.md/request, including private requests delivered exclusively to you. You can also contribute improvements via pull requests after opening an issue.

Summary & Recommended Actions

awesome design md is the rare GitHub phenomenon that arrived at exactly the right moment: DESIGN.md went from a Google Stitch experiment to an open industry standard in April 2026, and awesome design md became the community's default library for it — 108K stars, 73 design systems, and a global rank of #105.

If you build UI with AI agents, awesome design md is the fastest way to go from blank page to polished, design-consistent interface. It's free, MIT-licensed, deeply analyzed, and actively maintained.

Your next steps:

Star the repo — follow github.com/voltagent/awesome-design-md to track updates and new additions.
Try one today — copy the Vercel or Linear DESIGN.md into a scratch project and ask your agent to build a landing page; you'll see the difference within minutes.
Contribute or request — found a wrong color or missing token? Open an issue or PR. Need a brand that's not there? Use the getdesign.md request form.

Sources: awesome design md on GitHub · Google Stitch DESIGN.md overview · Google Labs: DESIGN.md format open-sourced · Google: Design UI using AI with Stitch · Star History for awesome design md · Banani: What Is Design.md and How to Use It · Medium: Google Makes DESIGN.md Open Source

Originally published at: awesome design md (2026): The Complete Guide to Google's DESIGN.md Collection

DeepSeek V4 Pro 0813 (2026): Complete Guide to Pricing, Benchmarks & How It Stacks Up Against Fable 5

cz — Thu, 13 Aug 2026 00:30:30 +0000

DeepSeek V4 Pro 0813 (2026): Complete Guide to Pricing, Benchmarks & How It Stacks Up Against Fable 5

🎯 Core Takeaways (TL;DR)

DeepSeek V4 Pro 0813 is the general-availability (GA) release of DeepSeek's 1.6T-parameter MoE flagship, live on August 12, 2026 — the official deepseek-v4-pro API endpoint now points to this build.
The headline story is agentic coding: DeepSWE jumped from 12.8 to 62.7, CyberGym from 52.7 to 83.3, and Terminal Bench 2.1 from 72.1 to 87.9 versus the preview — near Fable 5 territory at roughly 1/60th of the price.
Pricing is $0.435 per million input tokens (cache miss), $0.003625 (cache hit), and $0.87 per million output tokens, with a 1M-token context window — though DeepSeek has announced a significant price increase is coming.
DeepSeek V4 Pro 0813 has no vision support, a quirk that split the community — some see it as a dealbreaker, others as a reasonable trade for frontier-adjacent performance at budget pricing.

What Is DeepSeek V4 Pro 0813?
DeepSeek V4 Pro 0813 Pricing Breakdown
Benchmarks: The Big Agentic Gains
DeepSeek V4 Pro 0813 vs Fable 5 vs Opus 4.8
Real-World Feedback: What Early Users Report
How to Access DeepSeek V4 Pro 0813
FAQ

What Is DeepSeek V4 Pro 0813?

DeepSeek V4 Pro 0813 is the general-availability build of DeepSeek V4 Pro, DeepSeek's large-scale mixture-of-experts (MoE) model. The "0813" suffix marks the August 13 build identifier that closed out a preview period stretching back to the V4 family's open-weight debut on April 24, 2026.

Under the hood, DeepSeek V4 Pro 0813 is a massive model: 1.6 trillion total parameters with roughly 49 billion active per token, pretrained on more than 32 trillion tokens. It uses a hybrid attention system designed to cut inference costs at long context lengths — which matters, because the model supports a 1,048,576-token (1M) context window and up to 384,000 output tokens.

The release was staged deliberately. The smaller DeepSeek V4 Flash graduated to official status first on July 31, 2026, with DeepSeek's changelog promising the Pro release "will follow soon." That promise materialized on August 12, when the deepseek-v4-pro endpoint on DeepSeek's official API silently began pointing at DeepSeek V4 Pro 0813. Notably, as Simon Willison pointed out on Hacker News, DeepSeek shipped this upgrade without a blog post or even a tweet — the only announcement was the API documentation update itself.

💡 Professional Tip: Because DeepSeek V4 Pro 0813 shipped without an official announcement page, the most reliable places to track it are the DeepSeek API pricing page and its OpenRouter model page.

DeepSeek V4 Pro 0813 Pricing Breakdown

For an open-weight model of this size, DeepSeek V4 Pro 0813 is priced aggressively:

Pricing Metric	DeepSeek V4 Pro 0813	DeepSeek V4 Flash 0731
Input (cache miss) / 1M tokens	$0.435	$0.14
Input (cache hit) / 1M tokens	$0.003625	$0.0028
Output / 1M tokens	$0.87	$0.28
Context window	1M	1M
Max output	384K	384K
Concurrency limit	500	2,500

The cache-hit price is the sleeper stat. On OpenRouter, the measured cache hit rate for DeepSeek V4 Pro 0813 averages 88.9–92.17%, which drags the weighted-average input price customers actually pay down to about $0.051 per million tokens — roughly 1/8 of the listed rate. One HN user ran a heavy agentic workload (traffic simulator and distributed physics engine) all day for about $12.50, and commenters noted that with a properly configured harness pushing cache hits toward 99%, the same workload would cost a few dollars.

Two caveats worth knowing before you build on DeepSeek V4 Pro 0813:

⚠️ Attention: DeepSeek's official pricing page states it "plans to raise the overall pricing for DeepSeek API services in the near future, with a significant increase expected." Budget accordingly.

⚠️ Attention: Until more providers come online, OpenRouter routes DeepSeek V4 Pro 0813 directly through DeepSeek's official API, which may log and train on your prompts. Check DeepSeek's data policies before sending sensitive code.

Benchmarks: The Big Agentic Gains

The reason DeepSeek V4 Pro 0813 dominated Hacker News and r/LocalLLaMA on release day is the sheer size of the post-training jump. DeepSeek's official numbers (shared via its WeChat group and reposted by OpenRouter) show gains that would normally take a full model generation:

Benchmark	V4 Pro 0813	V4 Pro Preview	Gain
DeepSWE	62.7	12.8	+49.9
CyberGym	83.3	52.7	+30.6
NL2Repo	61.5	38.5	+23.0
Terminal Bench 2.1	87.9	72.1	+15.8
Toolathlon-Verified	74.1	55.9	+18.2
AutomationBench (Public)	31.8	12.8	+19.0
DSBench-FullStack	71.1	41.8	+29.3
DSBench-Hard	67.2	31.1	+36.1

The DeepSWE number deserves a double take. Across two releases, DeepSeek's engineering benchmark score went 7.3 → 12.8 → 62.7. As one Redditor put it: "The jump on DeepSWE is probably the most interesting number here. 7.3 → 62.7 in two releases is kind of wild 😅". DeepSeek attributes these gains entirely to improved post-training — the architecture of DeepSeek V4 Pro 0813 is unchanged from the preview.

DeepSeek V4 Pro 0813 vs Fable 5 vs Opus 4.8

The comparison that set the community buzzing: DeepSeek V4 Pro 0813 lands within a few points of Anthropic's frontier models on agentic benchmarks, at a fraction of the cost.

Benchmark	DeepSeek V4 Pro 0813	Opus 4.8	Fable 5 (w/ fallback)	Kimi K3	GLM-5.2
Terminal Bench 2.1	87.9	85.0	88.0	88.3	81.0
Cybergym	83.3	78.3	83.1	80.0	–
DeepSWE	62.7	58.0	70.0	67.5	46.2
Toolathlon-Verified	74.1	76.2	77.9	76.5	59.9
HLE (with tools)	60.0	57.9	63.0	56.0	54.7
AutomationBench (Public)	31.8	27.2	29.1	30.8	12.9
DSBench-Hard	67.2	71.7	68.3	63.0	54.5

One HN user computed geometric means across these suites: GPT-5.6 Sol leads at 65.5, Fable 5 at 64.5, Opus 5 at 64.0 — and DeepSeek V4 Pro 0813 at 62.5, ahead of Kimi K3's 62.3. That puts a $0.435/$0.87 model inside ~2 points of the most expensive models on the market. As r/LocalLLaMA commenters put it: "Close to Fable, nice. Comparing the pricing — nicer." and "this model is $0.87 per million tokens folks... basically 1/60th of Fable's cost."

✅ Best Practice: If your workload is text-only agentic coding, DeepSeek V4 Pro 0813 is the value play. If you need multimodal input, situational awareness for safety-sensitive reasoning, or maximum single-task reliability, a frontier model like Fable 5 or Opus still justifies its premium.

Real-World Feedback: What Early Users Report

Vibes on DeepSeek V4 Pro 0813 are mostly positive, with two recurring criticisms:

The wins:

A traffic-simulator workload found "some pretty significant gains without introducing any new problems" (~$12.50 for 2B tokens at 50% cache hits).
Simon Willison's SVG-rendering tests showed distinct, coherent "styles" at low/medium/high reasoning efforts — "almost like 3 models in one," as one commenter observed.
Local-hosting enthusiasts report you can self-host the open weights on a >128GB VRAM + 768GB RAM rig built from used P40s for roughly $3–3.5K.

The criticisms:

One HN test on Codex CLI: DeepSeek V4 Pro 0813 took 12m02s and $0.12 to add a feature but shipped with a bug, while Grok 4.6 took 3m18s and $1.41 with no bug. n=1, but it matches the general pattern: cheaper and slower, usually good enough.
Chinese developer karminski3 reported that with reasoning_effort=max on long-horizon agentic coding, the model tends to stop early: in a 50-round optimization loop, 2 of 3 runs halted around round 42–43 without using all available attempts, and it didn't beat GLM-5.1 in that setup. If you run long autonomous loops on DeepSeek V4 Pro 0813, monitor for premature termination.
No vision. DeepSeek reportedly doesn't consider vision part of its AGI path, so it's not on the roadmap — the single biggest feature complaint on both Hacker News and Reddit.

How to Access DeepSeek V4 Pro 0813

graph TD
A[Choose an access route] --> B[DeepSeek official API<br/>model: deepseek-v4-pro]
A --> C[OpenRouter<br/>model: deepseek/deepseek-v4-pro-0813]
B --> D[Enable thinking mode + tool calls]
C --> D
D --> E[Maximize cache hits<br/>never rewrite conversation history]
E --> F[Monitor long agent loops<br/>for early stopping]

You can reach DeepSeek V4 Pro 0813 today through:

DeepSeek's official API — the deepseek-v4-pro endpoint now serves the 0813 build; OpenAI-format, Anthropic-format, Responses API, JSON output, and tool calls are all supported.
OpenRouter — deepseek/deepseek-v4-pro-0813, currently hosted by a single provider (DeepSeek) with 100% uptime over the last three days, ~61 tokens/s throughput, and ~1.56s P50 latency. Early traffic shows Hermes Agent, pi, and Claude Code among the top apps already routing to it.
Self-hosting — the MIT-licensed open weights mean you can run it on your own hardware if you have the VRAM/RAM budget.

🤔 FAQ: DeepSeek V4 Pro 0813

Q: What is DeepSeek V4 Pro 0813?

A: DeepSeek V4 Pro 0813 is the general-availability (GA) release of DeepSeek V4 Pro, a 1.6T-parameter mixture-of-experts model with ~49B active parameters, a 1M-token context window, and up to 384K output tokens, released on August 12, 2026.

Q: How much does DeepSeek V4 Pro 0813 cost?

A: DeepSeek V4 Pro 0813 costs $0.435 per million input tokens on a cache miss, $0.003625 per million on a cache hit, and $0.87 per million output tokens. DeepSeek has announced a significant price increase is planned in the near future.

Q: What is the context length of DeepSeek V4 Pro 0813?

A: DeepSeek V4 Pro 0813 supports a 1,048,576-token (1M) context window with a maximum output of 384,000 tokens — enough for full-codebase analysis and long-horizon agent sessions.

Q: Does DeepSeek V4 Pro 0813 support tool calling and structured outputs?

A: Yes. DeepSeek V4 Pro 0813 supports tool calls, JSON output, the Responses API, both OpenAI and Anthropic API formats, and thinking/non-thinking modes. Reasoning efforts high and xhigh are supported, with xhigh mapping to max reasoning.

Q: Does DeepSeek V4 Pro 0813 support vision?

A: No. DeepSeek V4 Pro 0813 is text-only. DeepSeek has signaled that vision isn't on the roadmap for the V4 Pro line, which is the most common complaint about the model on Hacker News and r/LocalLLaMA.

Q: When was DeepSeek V4 Pro 0813 released?

A: DeepSeek V4 Pro 0813 went live on August 12, 2026, when DeepSeek's official deepseek-v4-pro API endpoint switched from the April preview build to the 0813 build. It appeared on OpenRouter the same day.

Q: Is DeepSeek V4 Pro 0813 open source?

A: Yes. The V4 series (Pro and Flash) was released as MIT-licensed open weights on April 24, 2026, and DeepSeek V4 Pro 0813 retains that license, so you can self-host and commercialize freely.

Summary & Recommended Actions

DeepSeek V4 Pro 0813 is the clearest proof yet that open-weight models have closed the agentic-coding gap to the frontier — 62.7 on DeepSWE, 87.9 on Terminal Bench 2.1, and a geometric mean within ~2 points of Fable 5, at roughly 1/60th of the price. It's not the best model in the world: it lacks vision, it's slower than Grok-class models, and at least one long-loop test found premature early stopping. But for text-only coding agents, batch work, and cost-sensitive pipelines, it resets the value equation.

Your next steps:

Try it for $1: spin up a test on OpenRouter with a real coding task and compare against your current model.
Optimize for cache hits: keep system prompts and conversation history byte-stable — at $0.003625/M, cache hits are where DeepSeek V4 Pro 0813 gets absurdly cheap.
Hedge the price increase: DeepSeek has flagged a "significant" API price hike; test DeepSeek V4 Pro 0813 now while the preview-era pricing lasts, and keep Flash 0731 in your back pocket for high-volume workloads.

Sources: OpenRouter model page & FAQ · DeepSeek API pricing docs · Hacker News discussion · r/LocalLLaMA benchmark thread · OpenRouter announcement on X · karminski3 agent-loop test · GMICloud release analysis

Originally published at: DeepSeek V4 Pro 0813 (2026): Complete Guide to Pricing, Benchmarks & How It Stacks Up Against Fable 5

DEV Community: cz

What Is Jev? The 2026 Complete Guide to TypeSafe's System One Model (200x Faster, 400x Cheaper AI Decisions)

🎯 Key Takeaways (TL;DR)

Table of Contents

What Is Jev and Why Doesn't It Generate Text?

What Exactly Is a "System One Model"?

How Does Jev Work?

Three Question Types

Batch Questions, Almost No Extra Latency

The Decision Flow

📊 Jev Decision Workflow

Training: RLCD

Performance and Pricing: What Does 200x Faster Mean?

How to Get Started with Jev (Three Paths + Code)

Path 1: Cloudflare Workers AI (Model ID: typesafe/jev)

Path 2: OpenRouter (Model ID: typesafe/jev-1.13)

Path 3: LangChain (the langchain-typesafe package)

Jev vs Traditional LLMs: Which Should You Use?

What Are the Real-World Use Cases?

Limitations and Caveats

🤔 Frequently Asked Questions

Q: Will Jev replace LLMs?

Q: What does "Noul" mean?

Q: How much does Jev cost?

Q: Where can I use Jev?

Q: Is Jev really hallucination-free?

Q: What kind of project should adopt Jev?

Conclusion and Next Steps

References

Antique Scanner: How to Identify & Value Antiques by Photo (2026 Complete Guide)

🎯 Key Takeaways (TL;DR)

Table of Contents

What Is an Antique Scanner?

What Can You Scan?

How Does Antique Scanner Work?

What's Inside an Antique Scanner Report?

Antique Scanner vs. Google Lens vs. Traditional Appraisal

How to Photograph Your Antique for the Best Results

Who Should Use an Antique Identifier?

Pricing: What Does a Scan Cost?

How Accurate Is It? Honest Limits

🤔 Frequently Asked Questions (FAQ) {#faq}

Q: How is Antique Scanner different from Google Lens?

Q: How accurate is the identification?

Q: Can it read pottery marks and silver hallmarks?

Q: Is this a real appraisal?

Q: Can the antique identifier tell if my item is a reproduction?

Q: How many photos should I upload?

Q: What does a scan cost?

Q: How long does an identification take?

Q: What happens to my photos?

Q: Does it work for items from any country?

Q: Can one scan cover a set of items?

Conclusion & Next Steps {#conclusion}

AI 80s Photo Generator (2026): Turn Any Selfie into a 1985 Photo

🎯 Key Takeaways (TL;DR)

Table of Contents

What Is an AI 80s Photo Generator?

What Is an 80s Photo Prompt?

The 80s Photo Prompt (Copy and Paste)

Method 1: How to Use the 80s Photo Prompt in ChatGPT

Method 2 (Simpler): The One-Click 80s Photo Generator

80s Photo Generator vs ChatGPT: Which Should You Use?

10 Real Before/After Examples

Tips for the Best Result

How Much Does an 80s Photo Cost?

🤔 Frequently Asked Questions

Q: What is an 80s Photo Generator?

Q: What is an 80s Photo Prompt?

Q: Is this the same as the ChatGPT 80s photo trend?

Q: Does the 80s Photo Generator keep my face?

Q: Can I use the 80s Photo Prompt for free?

Q: What photo should I upload?

Q: Are my photos stored?

Q: Can I generate other decades, like the 90s or Y2K?

Conclusion and Recommendations

Meta Glasses Converter – Official Website, What It Is & How to Use

🎯 Key Takeaways

Meta Glasses Converter Official Website

What Is Meta Glasses Converter?

Path 1: Cloudflare Workers AI (Model ID: `typesafe/jev`)

Path 2: OpenRouter (Model ID: `typesafe/jev-1.13`)

Path 3: LangChain (the `langchain-typesafe` package)