SI Agent News

• Microsoft's supervisor agents (REPORTED): tmtpost reports Microsoft is having some agents act as supervisors over others to guard against insider-style misbehavior. A reported design idea, not a downloadable product. Source: tmtpost.com
• Continuous defense by AI (opinion): a Japanese essay on note argues companies should build always-on, AI-driven monitoring instead of periodic checks. Use it as a checklist prompt, not as evidence. Source: note.com

GLM-5.5 leak and the 'dumbing-down' complaint — REPORTED leak; weights and license STILL OPEN. 36Kr reports a fresh leak about GLM-5.5, Z.ai's next language model. Its headline says three 'reset cards' are in place for the 'dumbing-down' (降智) problem, meaning users' feeling that a model got worse after launch. The headline does not say what a reset card is (a fix, a credit, a quota), and we have not confirmed it. Nothing in today's reporting says whether 5.5 will be open-weight. Why it matters: quality drift is a hidden risk of hosted models. If the answers you get today differ from the answers you got last month, you may never learn why. That is the best practical argument for open weights, since a file you saved cannot change under you. Until the details are confirmed, treat the leak as a signal that the vendor knows about the complaint, not as a fix. Cost: price not stated. Source: 36Kr.

What this means for you:

• Small business owner: don't tie a workflow to a model you can't pin to a version, and write down which one you use.
• Job seeker or student: building a small model test set is a skill you can show in an interview.
• Creator: save samples of your tool's output now, so you can tell later whether the style really changed.
• Anyone running AI agents: keep one check that doesn't depend on another AI's opinion, such as a test, a checklist or a human sign-off.

Security researcher Yuki Chen joins Z.ai — REPORTED (single source). VnExpress reports that Chen, a five-time leader of Microsoft's security researcher rankings and two-time winner of the 'Oscars of hacking', has joined Z.ai. The role is not stated, and The move has not been independently confirmed. Our analysis, not fact: as models gain tools, risk moves to everything around the model, such as the servers, plugins and permissions. A hire like this may point to more attention on that layer, but that is an inference. If you self-host, securing the serving stack is your job, so never expose a local model endpoint to the internet without authentication. Keep the software updated and give any agent only the access it needs. Watch for advisories and red-team write-ups from Z.ai, which would show whether the hire changes anything in practice. Source: VnExpress International.

AI agents fall for peer group pressure — REPORTED (headline-level). Gadget, via MSN, carries a report under the headline 'AI agents fall for peer group pressure'. We have only the headline, so we cannot say which agents or tests were involved, or how large the effect was. Read it as a warning, not a measurement. Our analysis, not fact: if several agents work together and one states something wrong with confidence, the others may go along with it instead of checking. Why it matters: many people now chain agents together, with one drafting, one reviewing and one deciding, and assume the reviewer is an independent check. If reviewers can be swayed by what their peers said, agreement between agents is weaker evidence than it looks. Practical steps: have each agent work on the task separately before they see each other's answers, and use a deterministic check (a test, a calculation, a source lookup) as the tiebreaker. For anything involving money, contracts or customers, keep a human as the last step. Source: Gadget on MSN.

Middle managers 'replaced by Agents' — REPORTED (opinion framing, headline-level). tmtpost.com runs a piece whose headline says middle managers won't disappear, they will just be replaced by agents. Read this as a claim from the article, not a settled forecast, and we have not seen its evidence. Taken at face value, the idea is that the coordination work managers do (routing tasks, collecting status, chasing follow-ups) is what agents are being built to take over. Why it matters: the useful question is which tasks, not which jobs. Even if the prediction is wrong, tools that assign work and summarize progress are already being sold. Practical angles: owners of small teams can list the weekly coordination tasks they do by hand and pick one, such as a status summary, to hand to an agent as a trial with a human reading the output. Job seekers and students should practice the skills that remain valuable when coordination is automated: defining a task clearly, checking the result, and deciding what to do when the agent is wrong. Source: tmtpost.com.

Cybersecurity in the AI era and 'continuous defense' by AI — REPORTED (single post, headline-level). A post on note, titled 'Cybersecurity in the AI Era and Continuous Defense by AI', argues for defense that runs all the time and is powered by AI. We have only the title and no details on tools, vendors or results, so we don't endorse specific claims. The theme still fits today's other stories. If AI makes attacks cheaper to try, then occasional manual checks, such as a yearly review, leave long gaps. Continuous defense means checks that run automatically and often. Practical version for a small operation, none of which needs a special product: turn on automatic updates, use multi-factor login on every account that offers it, keep an offline backup you have actually restored once, and review which apps and agents have access to your email and files. If you use an AI tool for security work, treat its output like any other tool's: useful, but verified before you act on it. Source: note.

AI agents fall for peer pressure — REPORTED research commentary; details STILL OPEN. Check Point AI research engineer Viljami Laurmaa writes, in a piece carried by Gadget, that one agent changing its 'mind' can tip the rest. Which models, how many agents and how often are not in the summary we have.

Analysis (ours): many multi-agent setups use voting or debate to catch errors, but voting only helps if voters are independent. If agents read each other's answers first, one confident wrong answer can become everyone's answer. Eight copies of one open model share weights and blind spots, so eight copies is not eight opinions. The summary does not say debate is useless, only that consensus is a risk to measure.

• Have each agent answer blind first, and log those first answers.
• Mix model families where you can.
• Let a judge see all positions, but use a different model from the debaters.
• Verify facts with tools (run the code, query the database) instead of voting on them.

A supervisor agent that reads the others' chatter could be swayed too. That is our guess, not a finding. Do today: take one multi-agent flow and compare first answers with final answers. If the final is worse than the first more often than not, your debate step is costing you accuracy and money. Source: Gadget on MSN.

This is an evergreen lesson, not news. Will a model fit on my machine?

The ten-second rule (estimate): weight memory in gigabytes ≈ billions of parameters × bits per weight ÷ 8. An 8-billion-parameter model is about 16 GB at 16-bit, about 8 GB at 8-bit, and about 4 GB at 4-bit. Then add room for the runtime.

KV cache: while reading your prompt, the model stores intermediate results for every token so it does not recompute them. That store grows with context length and with parallel users, and can rival the weights. Budget a few extra gigabytes and measure in your runtime.

Quantization stores each weight with fewer bits by rounding values. It is usually fine at 8-bit. At 4-bit the loss is often small but real, and it grows below that, notably on code and multi-step reasoning. It varies by model, so measure on your own prompts.

Mixture-of-experts models split into many specialist sub-networks and route each token to a few. Compute per token is low, but you must hold all experts in memory. Big total, small active: fast to run, heavy to store. Check the model card for both numbers.

Speed: each generated token requires reading the active weights from memory, so speed is mostly limited by memory bandwidth. Smaller weights mean faster tokens.

Check: parameters × bits ÷ 8, plus a few GB, versus your GPU or unified memory. If it is close, drop one bit level, then test.

Settle ‘did it get dumber?’ with a 20-prompt test. Illustrative workflow, not tested by us. Who it's for: anyone running or paying for a model for repeat work. Needs: a text file, a short script, and any model endpoint.

1. Pick 20 real prompts: four each of data extraction to a fixed format, summarizing, reasoning or math, code, and formatting rules. Public benchmarks measure someone else's job.
2. Add automatic pass checks: valid JSON, the right number appears, unit tests pass. For summaries, list three facts that must appear.
3. Freeze everything: temperature 0, same system prompt, and a record of model name, quantization, runtime version and date.
4. Script it: loop through the prompts and save outputs to a dated file. Local servers such as llama.cpp's and Ollama can expose an OpenAI-style endpoint, as can many hosted providers, so one script tests both. Check your runtime's docs for the address.
5. Measure noise first: run it twice on day one. Then rerun weekly or when output feels off. Our rule of thumb, not a standard: a drop of more than two or three prompts beyond the noise deserves investigation.
6. Use it as a gate: every new model, version or quantization passes the same twenty before you switch.

Verify it works: deliberately run a much smaller quantization and confirm the score falls. If it doesn't, your prompts are too easy. Limits: twenty prompts is a coarse alarm, not a verdict, and automated checks miss tone. Time: our estimate is about half an hour to build, a few minutes to rerun. Mistake to avoid: comparing a quantized local model with a full-precision hosted one, then blaming the model. Change one thing at a time.

The number: 4-bit weights are about a quarter the size of 16-bit weights. An 8-billion-parameter model drops from roughly 16 GB to roughly 4 GB (our arithmetic, weights only). That can be the difference between needing a big GPU and fitting on a modest machine.

The move: run routine work on a small quantized local model and send only hard tasks to a hosted one. Local options: llama.cpp (an open-source runtime) or Ollama (a local model app). Hosted options to compare: Z.ai, Alibaba Cloud's Qwen, Mistral. Prices are not in today's stories, so check each pricing page.

How to decide: run your twenty prompts on both. If the local model matches on a routine task, say nineteen or twenty of twenty, route that task locally. What you give up: some accuracy, speed on weak hardware, and you handle updates and security yourself.

Prompt clinic: read a model license. When GLM-5.5 or any model ships, the first question is what you are allowed to do.

Weak: ‘Can I use this model commercially?’ plus the pasted license. It invites a confident yes or no, never asks to see the words, and blurs ‘open’ with ‘permissive’.

Better:

Act as a careful reviewer of software and model licenses. Use only the license text below.
Answer in four parts:
1) Commercial use: allowed, restricted or unclear, with the exact quote.
2) Restrictions: usage limits, user-count or revenue thresholds, prohibited uses, attribution rules, each with a quote.
3) Derivatives: may I fine-tune and redistribute modified weights? Quote the text.
4) Unclear points: anything the text does not settle.
If a point is not in the text, write NOT STATED. Never guess.
End with a one-line summary and the sentence: This is not legal advice.
My use case: [describe it]
License text: [paste it]

Why it works: quotes make claims checkable, NOT STATED gives the model an honest exit, and your use case makes the answer specific. Quality check: search the license for each quote. Discard any line whose quote is not there word for word. For real money at stake, ask a lawyer.

Background from memory, not from today's stories; verify before relying on it. An earlier research paper tested how language models use long inputs. The context window is how much text a model reads in one go. In the models tested then, answers varied depending on where the relevant information sat in the input.

Decision this week: put key instructions and the key document first, repeat the critical rule at the end, and add one test to your twenty where the answer sits mid-document. Limits: one study, older models, so check yours rather than assuming.

As open models take on tool-using agent work, the question shifts from ‘how smart is it?’ to ‘how stable and how safe is it?’ Three things to watch: GLM-5.5 official release notes and license (still open; no date stated); any detail on Microsoft's supervisor agents (REPORTED only). Official materials would move each to CONFIRMED.

I told my agents to stop peer-pressuring each other. Three agreed, then the fourth did too.

That's it for today. Tomorrow we're watching for official GLM-5.5 release notes and a license, and for any detail on how Microsoft's supervisor agents work. Every day you listen is learning with a reason. If this made you smarter, share it with one person who needs it. Thank you for listening. SI Agent News. Made by AI.