SI Agent News

• A developer on Habr (a Russian tech site) put an AI agent in his MacBook's notch; it listens to his day and hands tasks to separate Claude Code sessions. Claude Code is Anthropic's coding agent, so that part is not open. Habr · REPORTED (self-described build)
• S-Agent 2.0 (arXiv preprint) applies a general coding agent to spatial reasoning, meaning working out where objects are in 3D space. arXiv · REPORTED
• A second arXiv preprint studies networking for on-device agents that assist real-time communication. arXiv · REPORTED

DeepSeek fully open-sources DeepInfer, its inference framework

An inference framework is the software that runs a trained model to answer prompts. It decides how requests are batched, how memory is used and how fast answers come back. TechNews (Taiwan), citing Chinese media, reports DeepSeek announced on the 20th that it is fully open-sourcing DeepInfer. This follows earlier open releases of a series of large models, the TileLang compiler tool, and a library of inference operators (low-level math routines a model runs on the chip). Releasing the serving layer as well as the models means outsiders can see how the models are actually run, not only download them.

Status: REPORTED (announcement via secondary coverage). STILL OPEN: the license, hardware requirements, supported models and any speed numbers. The stated goal, making large models accessible to all, is an aim, not a measured result.

Do this: when the repository is public, read the license first, then the hardware list, then whether any benchmark names its source and can be reproduced. Cost: price not stated. Worth it for teams that self-host or want to learn how serving works.

What this means for you:

• Small business owner: if you plan to run a model on your own server, wait for the hardware list before buying anything.
• Job seeker or student: a full open serving stack is free study material for how large models are actually run.
• Creator: if you generate lots of text, self-hosting may cut per-use fees, but no savings figure exists yet.

Source: technews.tw

China opposes US restrictions on DeepSeek

China Daily's European edition reports that China opposes US restrictions on DeepSeek. This is the Chinese side's stated position, carried by a Chinese outlet, so read it as one party's framing rather than a neutral account. The headline does not tell us which restrictions are meant, whether they cover government devices, exports, or something else, or when they would apply. We have not seen the text of any US measure.

Status: REPORTED, one-sided. STILL OPEN: the exact scope of the restrictions, who they bind, and whether they touch the openly released model files or only the hosted DeepSeek service.

Why it matters: that last distinction is the practical one. Using a company's hosted app means your prompts go to its servers. Running openly released weights on your own machine does not. If your employer, client or country has a policy on this vendor, check it before you build on it.

Do this: keep a note of which DeepSeek products you rely on (hosted service, API, or self-hosted files), so you know quickly what a rule would affect. Cost: free.

Source: europe.chinadaily.com.cn

For coding agents, the repository matters

An arXiv paper titled 'For Coding Agents, the Repository Matters' argues, going by its title, that how a codebase is set up affects how well AI coding agents work in it. We have only the title and listing, not the results, so we can't say how large the effect is, which agents were tested, or which repository traits count most.

Status: REPORTED (preprint, not yet peer reviewed as far as we know). STILL OPEN: the measured effect, the benchmark used and whether it holds on your kind of project.

Why it matters: most agent talk is about picking the model. This points at the other half: the code the agent has to read. Common-sense changes may help, such as clear folder names, a short README on how to build and test, and tests that run quickly. Treat that as a hypothesis to try, not a proven result.

Do this: pick one small repo, give an agent the same task before and after you tidy it and add a build-and-test note, and compare. Cost: free apart from your agent usage.

For you: developers and students get a cheap experiment; team leads get a reason to treat repo hygiene as agent infrastructure.

Source: arxiv.org

How to run OpenClaw (Moltbot/Clawdbot) with local models like Ollama

A dev.to guide explains how to run OpenClaw, which the title also lists as Moltbot and Clawdbot, with local AI models through tools such as Ollama. Ollama is a program that downloads and runs open models on your own computer. The appeal is that the agent's model calls stay on your machine instead of going to a paid cloud API.

Status: REPORTED (community tutorial, not official documentation). STILL OPEN: which local models work well, how much memory they need, and how the agent behaves compared with a cloud model. Smaller local models are often weaker at multi-step tasks, so expect trade-offs.

Do this: follow the guide on a spare or non-critical machine first. Check what permissions the agent asks for (files, shell, accounts) before granting them, and begin with a small model to confirm it works before downloading a large one. Cost: free software; your hardware and electricity are the cost.

For you: hobbyists and small businesses with privacy concerns get a way to try agents without per-use fees. Anyone handling client data should still check where the agent writes logs.

Source: dev.to

The EU wants independent, secure AI

DW reports the EU wants independent, secure AI and hopes to catch up with the US and China. REPORTED; the coverage we have is light on specifics, so no budget or rule is confirmed. Independent is not the same as open, since a closed European model would also meet the goal. 'Secure' could mean data protection, supply-chain security or safety testing, and the headline does not say which.

STILL OPEN: funding, timelines, which companies would benefit, and whether the plan changes any current obligations for AI providers.

For builders: if you sell into Europe, keep your model layer swappable, so you can change providers if procurement rules or customer demands shift. A thin wrapper around model calls is a cheap form of insurance. For everyone else: nothing to do yet; watch for concrete announcements.

Source: DW

An AI agent in the MacBook notch that hands tasks to Claude Code sessions

A Habr author describes building an AI agent that sits in the MacBook's notch, listens to their day and hands out tasks to Claude Code sessions. Claude Code is Anthropic's coding agent. The idea is a coordinator: it picks up what you say and do, turns it into tasks, and routes them to separate coding sessions running in parallel.

Status: REPORTED (one developer's personal project). STILL OPEN: whether it is released for others, how accurate its task extraction is, and where the audio is processed and stored.

Why it matters: it shows where agent tools are heading, from you typing a prompt to a background layer that decides what to delegate. It also raises the obvious caution: a tool that listens all day handles sensitive speech, so check where recordings go before copying the idea.

Do this: if you want to try something similar, start with a manual version: write down your tasks, then paste each into its own coding session. See whether the routing is worth automating. Cost: not stated.

Source: habr.com

S-Agent 2.0: spatial reasoning with a general coding agent

An arXiv paper, 'S-Agent 2.0: Spatial Reasoning with a General Coding Agent', suggests, from its title, that a general-purpose coding agent can be used for spatial reasoning tasks. Spatial reasoning means working out where things are and how they relate in space, such as layouts, positions or geometry. The likely idea is that the agent writes and runs code to work out the answer instead of guessing from text alone, but we have only the title, so treat that as an inference.

Status: REPORTED (preprint). STILL OPEN: the benchmarks, the scores, which model sits underneath and how it compares with earlier versions.

Why it matters: if code-writing agents can handle spatial problems, a single tool covers more jobs, from floor plans to map data to simple robotics planning. For readers, the lesson that carries over is that having a model compute an answer is often more reliable than having it describe one.

Do this: read the abstract and the results table before relying on the claim. Cost: free to read.

Source: arxiv.org

Coordinated networking for on-device agent-augmented real-time communication

Another arXiv paper, 'Coordinated Networking for On-Device Agent-Augmented Real-Time Communication', looks at the network side of AI agents running on a device during live communication, such as calls or video chats. On-device means the agent runs on your phone or laptop rather than in a data center. From the title, the problem is coordinating the network so the call and the agent's work don't get in each other's way. We have not seen the method or results.

Status: REPORTED (preprint). STILL OPEN: the proposed design, the measured delay or quality gains, and whether it was tested outside a lab.

Why it matters: live features such as captions, translation or meeting assistants depend on low delay. Running the agent locally can keep audio on your device, but it competes with the call for bandwidth and processing. Papers like this show where the engineering effort is going.

Do this: mostly a watch item. If you build real-time apps, skim the paper for its list of bottlenecks. Cost: free.

Source: arxiv.org

China objects to US restrictions on DeepSeek: what it means if you self-host

An update on a story we've covered before, not breaking news.

What's reported: China Daily's European edition reports China opposes US restrictions on DeepSeek. REPORTED by two outlets; China Daily gives Beijing's view, NBC is independent coverage of the same dispute.

STILL OPEN: the scope. It is unclear from what we have whether it touches a private company, or a person running downloaded weights on their own machine.

Why the distinction matters: a hosted app or API sends your prompts to the provider's servers. Running open weights yourself keeps the model where you decide. Those are different risks, and a restriction aimed at one does not automatically cover the other. Self-hosting does not erase every concern, because your organization's rules may be about where a model comes from, not where it runs.

Who is affected: anyone selling to government, and likely regulated industries. Who benefits: rival model providers and compliance consultants. Next to today's lead, the two trends do not cancel: policy narrows who may use a model, while open code widens who can study and rebuild it.

Do today:

• Ask your security or legal team in writing whether policy covers a model by origin or by where it runs.
• Keep the model name and endpoint in one config file so you can swap.
• Log which model version produced which output, in case of an audit.

Limit: we have headlines, not the text of the restrictions. Our analysis: expect procurement rules to name a model's origin, not just its vendor.

Sources: China Daily, NBC News

How an inference framework actually works

Background lesson, not news: the reports on DeepInfer do not describe its design, so this explains how model serving works in general.

Two phases. Your prompt is first read in one parallel pass (prefill). Then the answer is written one token at a time (decode). A token is a chunk of text, roughly a short word. Prefill is limited by raw compute. Decode is limited by memory bandwidth, because each token requires pulling the weights and the model's running notes from memory.

KV cache. Those notes are the key-value cache: saved math for every earlier token so the model does not redo it. It grows with every word of context and often exhausts memory before the weights do.

Three tricks serving software leans on:

• Batching: handle many requests together so one trip to memory feeds many answers. Continuous batching slots new requests in as others finish.
• Cache management, so memory is not wasted.
• Fast kernels: hand-tuned routines that run each operation on the chip.

Where DeepSeek's earlier releases fit. TileLang is described as a compiler tool and the operator library as low-level routines; a framework sits above them, so the open stack now runs from kernel to server.

Novel or incremental? STILL OPEN until the code is read. Open serving engines already exist (vLLM and llama.cpp, from our field knowledge, not today's stories); the question is whether DeepInfer is tuned for DeepSeek's models in a way those are not.

Use it anyway: the same levers appear as settings everywhere: shorter context, reused prompt prefixes through caching, and quantization (storing weights in fewer bits, trading a little quality for cost). Rule of thumb, labelled as one: the quantized file size is your memory floor, plus headroom for the cache.

Limit: batching raises total throughput but can add delay per user, so chat and overnight jobs want different settings. Our outlook, analysis only: with good documentation, the repository becomes a free textbook.

Point an agent at a model on your own machine

Inspired by: a dev.to guide on running OpenClaw (an open-source agent tool) with local models through Ollama (a free tool that runs models locally), pitched as a way to avoid token-bill shock and swap models by provider. Price not stated. This walk-through is illustrative; we have not tested it.

Who it's for: developers whose automations call a hosted model all day and who want a cheaper path for routine work.

ollama pull <model-name>
ollama list
curl http://localhost:11434/v1/models

1. Install Ollama and pull an open model (Qwen, Llama, Gemma or Mistral families) whose file is smaller than your free memory, with headroom.
2. Ollama serves a local API, with an OpenAI-compatible address ending in /v1. The curl line should list your model. Check Ollama's docs for your version.
3. In the agent's settings, set the provider base URL to http://localhost:11434/v1, a placeholder API key, and the exact model name from ollama list. Setting names differ by tool; follow the guide.
4. Permissions: the guide stresses sandboxed tool execution and strict permissions. Give the agent one folder, no network, and human approval for anything destructive.
5. Keep a hosted model as fallback. Route routine tasks (summaries, renames, formatting) to the local one.

Expected output: routine tasks finish with no per-token charge, but slower and sometimes worse. Verify: run the same five tasks on both models, compare results, and watch network traffic to confirm nothing leaves the machine.

Limits: small local models struggle with long multi-step tool use, and local is not free: you pay in hardware, electricity and time. Worth it for steady, repetitive, privacy-sensitive workloads; not for occasional use.

Source: dev.to

The 30-minute model-routing audit

That is our estimate, not a measured figure. Log one week of your model calls and sort each into two piles: needs a top model, or routine (formatting, extraction, classification, short summaries).

The math: routine tokens × hosted price per million tokens, minus the electricity and hardware cost of running the same work locally over the same period. If the result is negative, stay hosted. Today's stories state no prices, so check the current price on each provider's pricing page. Compare at least two vendors side by side: hosted APIs from OpenAI and Anthropic on one side, a local setup such as Ollama or llama.cpp on the other.

Also check first: whether your provider offers caching for repeated prompts or discounted batch processing for jobs that can wait. Either may beat self-hosting with no setup. See each provider's docs.

What you give up: quality on hard tasks, setup time, and a machine that has to stay on.