maxloh

I would say so.

There is a lot of noun phrase usage in places where complete sentences are expected. Articles (a, an, the), transition phrases and even subjects are mostly dropped, and the sentences are too long without a break.

Yeah. I've found that Opus by default outputs something I call "Claude-lang." It consists of oversimplified, grammatically incomplete sentences that I find painful to read.

Maybe it is something that is easy for it to read and write, but definitely not for humans.

For example,

  Skim once now; refer back while reading Part II. \*Every bold technical term in Part II is defined here\* — treat these as a dictionary, not a reading assignment. The first table covers the vocabulary of the *deck*; the three that follow cover the *methodology* vocabulary introduced in Part II, grouped so you can find a term fast: \*(A)\* the logic of rules, \*(B)\* the neural-network & training machinery, \*(C)\* the method-design ideas.

  JMRL is the paper the thesis instantiates, so this is the one to know cold. Its pitch is \*end-to-end\*: earlier rule methods (LogicRE, MILR) bolt a rule learner *onto a frozen* extractor in a pipeline and suffer \*error propagation\*; JMRL trains the rule module *jointly* with the extractor.

  **Identity.** Conformal prediction for NER producing **finite-sample-valid prediction sets** at two granularities: **full-sequence** sets over entire label sequences (capturing contextual dependence — "if Sarah=PER then NYC likely LOC") and **subsequence-level** (per-span, **class-conditional**) sets; an **integrated** method filters full-sequence predictions with entity-level sets. Adds **covariate-stratified calibration** by **sentence length and language** for valid multilingual coverage, and studies **combined nonconformity scores** (Naive / Conditional / RAPS). **Read in this order.** Abstract → §1 contributions (full-sequence / subsequence / integrated / **covariate (length + language) calibration** / combined scores) → §2 CP recap (inductive split-CP) → §3 NER formulation (IOB2, CRF) → the subsequence / entity-level set construction + class-conditional coverage → the language-stratified calibration results. **Why it matters here.** The **span-level construction** for **Topic 11**'s per-triple score, and — crucially — its **language-stratified calibration is exactly the EN↔zh case**: it shows how to keep conformal coverage valid across languages of differing length/script. Complements PASC (pipeline-level joint coverage) with the *NER-internal* set construction. **Caveat.** A heavy statistics paper (44 pp., *Annals of Applied Statistics* submission) with CRF-based NER; the project needs only the **inductive split-CP + subsequence/entity-level sets + language-stratified calibration**, not the full-sequence machinery (likely overkill for triple-confidence). Assumes exchangeability — borderline under the EN→zh shift, which is precisely why the PASC/ConformalNER *shift* analyses matter.

Not really. Gemini 3.6 Flash actually cost $0.01 more per task, compared to GLM 5.2.

https://artificialanalysis.ai/models/gemini-3-6-flash

I personally doubt that.

It would be a shame if they cannot beat Kimi K3 or Qwen3.8 Max, both of which are claimed to be Fable-like. If that is true, it will be [or would be] the first time a major American lab falls behind a Chinese competitor.

I am curious whether the model requires a font to be installed. Does it also generate the glyphs for the text?

Their "OpenCode" naming is controversial too.

Quoting moozilla's comment 11 months ago (https://news.ycombinator.com/item?id=44741894):

---

If anyone is curious on the context: https://x.com/thdxr/status/1933561254481666466 https://x.com/meowgorithm/status/1933593074820891062 https://www.youtube.com/watch?v=qCJBbVJ_wP0

Gemini summary of the above:

- Kujtim Hoxha creates a project named TermAI using open-source libraries from the company Charm.

- Two other developers, Dax (a well-known internet personality and developer) and Adam (a developer and co-founder of Chef, known for his work on open-source and developer tools), join the project.

- They rebrand it to OpenCode, with Dax buying the domain and both heavily promoting it and improving the UI/UX.

- The project rapidly gains popularity and GitHub stars, largely due to Dax and Adam's influence and contributions.

- Charm, the company behind the original libraries, offers Kujtim a full-time role to continue working on the project, effectively acqui-hiring him.

- Kujtim accepts the offer. As the original owner of the GitHub repository, he moves the project and its stars to Charm's organization. Dax and Adam object, not wanting the community project to be owned by a VC-backed company.

- Allegations surface that Charm rewrote git history to remove Dax's commits, banned Adam from the repo, and deleted comments that were critical of the move.

- Dax and Adam, who own the opencode.ai domain and claim ownership of the brand they created, fork the original repo and launch their own version under the OpenCode name.

- For a time, two competing projects named OpenCode exist, causing significant community confusion.

- Following the public backlash, Charm eventually renames its version to Crush, ceding the OpenCode name to the project now maintained by Dax and Adam.

Nevermind, I got it. Thank you.

Nevermind, I get it. Thank you.

I have successfully singed up. Thank you very much!

Hi. Could you send me an invite too? Email in my profile :)

Hi. Could you send me an invite? Email in my profile :)

Hi. Could you send me an invite? Email in my profile :)

What if the agent makes the wrong choice? How many tokens have been burned in the meantime?

It is much worse than that. Claude Code doesn't auto-commit when stopping for an answer. There might be possible data loss if an uncommitted file is edited.

Good luck recovering the file from the JSONL conversation history.

Yeah, we already have many open-source agent systems. If you prefer a UI, OpenCode itself has a beta desktop app.

I don't think we need closed-source developer tools, especially ones where they might restrict access if they decide to start charging for them later.

Could you update the repo without force-pushing or rewriting the commit history?

Also, it would be great if you could tag the versions as well.

No, it is possible with extensions.

Extensions can inject headers, such as Access-Control-Allow-Origin: *, to unblock cross-origin requests. In the Manifest V3 context, however, that might require patching window.fetch and window.XMLHttpRequest.

For example,

  // content.js
  window.fetch = async (...args) => {
    const request = args[0] instanceof Request ? args[0].url : args[0]
    const config = args[1] || {}

    return new Promise((resolve, reject) => {
      chrome.runtime.sendMessage({ action: "proxyFetch", request, config }, response => {
        if (response.error) {
          const err = new Error(response.error.message)
          err.name = response.error.name
          err.stack = response.error.stack
          if (response.error.cause) err.cause = response.error.cause
          reject(err)
        } else {
          const base64Data = response.dataUrl.split(",")[1]
          const bytes = Uint8Array.from(atob(base64Data), c => c.charCodeAt(0))
          const contentType = response.headers["content-type"] || "application/octet-stream"
          const blob = new Blob([bytes], { type: contentType })

          const status = response.status
          const statusText = response.statusText
          const headers = new Headers(response.headers)
          const body = status === 204 || status === 205 || status === 304 ? null : blob
          resolve(new Response(body, { status, statusText, headers }))
        }
      })
    })
  }

  // Background.js
  chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
    if (message.action === "proxyFetch") {
      fetch(message.request, message.config)
        .then(async res => {
          const headers = Object.fromEntries(res.headers.entries())
          const blob = await res.blob()
          const reader = new FileReader()
          reader.onloadend = () =>
            sendResponse({ status: res.status, statusText: res.statusText, headers, dataUrl: reader.result })
          reader.readAsDataURL(blob)
        })
        .catch(err => {
          const { name, message, code, stack } = err
          sendResponse({ error: { name, message, code, stack } })
        })

      // Keeps the message channel open for the async fetch
      return true
    }
  })

LLMs aren't just for coding and math. Many people understand the world through LLMs, even when it comes to philosophy and politics.

If you understand the world through a Chinese LLM, you are seeing it through a biased lens stemming from biased training data.

(Also, in that way, having all major LLMs developed by the US carries a risk too. We need more diversity than just the viewpoints of the US or China.)

I love Allen AI.

I find it wonderful that, as a non-profit, they are only one to two years behind SOTA models that cost billions of dollars to build, if not more.

Opencode is written in Go.

Why is that even a problem? If no images are released on the internet (and users consume them privately), no one is harmed in the process.

Blocking AI from generating sexualized images because people could publish deepfakes is no different than banning alcohol because of drunk driving.

Tools are neutral. Blame the people who misuse the tools and hurt others.

Has anyone tried building from source?

The commit message says "initial sync from the monorepo." Is this even compilable without the rest of the source code?

There is also ZLUDA, which is open source and works on pre-compiled binaries.

https://github.com/vosen/ZLUDA

Yeah. Not the Desktop App though.

IANAL, but calling this "relicensing" is technically inaccurate. It is more precise to describe it as adding constraints. When you combine your work with upstream code, you are layering additional requirements (like copyleft) onto the existing attribution requirements. The original limitations remain in effect. Therefore, it is not a shift from A to B, but rather from A to A ∪ B.

This practice is entirely compatible with the PostgreSQL License, but it is often prohibited by GPL variants. You typically cannot combine GPL code with code under most other copyleft licenses, such as the Eclipse Public License.

Regarding copyright status, AI-assisted work is increasingly recognized as copyrightable in many jurisdictions, provided the process involves a sufficient level of human creative input (though the specific threshold varies by jurisdiction). Only work generated purely by AI, with no human involvement, is arguably public domain. In a case like this, which is akin to "pair programming," the output is almost certainly copyrightable.

Edit: Found that their built-in skills are actually open-source: https://github.com/openai/plugins

I think that means those MEPs are not doing their jobs. They are the representatives of their people, but somehow they left for vacation before the last day of the session. They failed in the most important part of their duty.

Only its CLI is open source. The desktop app is always proprietary.

The PostgreSQL License is a variant of the BSD license and is therefore compatible with the (A)GPL.

Comprehend it this way: You create a blank (A)GPL project and incorporate the upstream BSD codebase into it. While those original upstream files remain under their original permissive license, the project as a whole is governed by the (A)GPL (plus the attribution requirements of the upstream license, which the GPL permits). From there, you can add your own code under the AGPL and distribute the combined work under the AGPL.

If someone takes your code and uses only your portion, they can use it under the AGPL alone. However, if they also include the upstream source code, then the attribution requirements of the upstream license must still be met.

Codex CLI is open source too. I don't think there is a difference.

I wish they open source their desktop app and built-in skills one day. That would be a final blow for me.