EN
Ihor Nikolenko- DeepSeek: Visual Tokens as a New Way to "Remember"
- IBM Granite 4.0 Nano: When Small Is the Right Call
- Microsoft 365 Copilot: An App Builder for Every Employee
- GitHub Agent HQ: One Dashboard for Many Coding Agents
- Intuit: Financial Agents Built Around Trust
- OpenAI Open-Sources Safety Model Weights
- What a Business Owner Should Take from This
- The Short Version
- Frequently Asked Questions
Just a year ago, the conversation about AI in business boiled down to two questions: "which model is smarter" and "how much does a query cost." The questions today are different: how do you keep a model from forgetting the context of a long session, how do you run one on your own laptop without the cloud, how do you let employees build their own tools without an IT department — and how do you keep control over what those tools and agents do with company data while you're at it?
This matters right now because a single wave of releases just showed where the industry is heading: toward compactness, local control, and governability. Not "more parameters," but "fewer resources for the same result." Not "replace the human," but "give the human a control panel." What required a corporate budget yesterday can be assembled on your own infrastructure today.
This roundup covers six pieces of news, each with its own "why should I care": DeepSeek's visual memory for models, IBM Granite's small models, an app builder inside Microsoft 365 Copilot, GitHub's control panel for coding agents, Intuit's cautious financial agents, and OpenAI's open safety models. And at the end, what to actually put to work this month.
DeepSeek: Visual Tokens as a New Way to "Remember"
DeepSeek unveiled an OCR model that's interesting not as just another text recognizer, but as a testbed for ideas about storing context. Instead of thousands of text tokens, the system packs pages into visual representations — "snapshots" of text — and applies hierarchical compression: older or less important fragments stay "blurry" but accessible, while important ones stay sharp.
Why it matters. What the industry calls "context rot" is a real problem for any long conversation or agent: the more history piles up, the worse the model holds on to the beginning, and the more expensive every query gets. Visual tokens preserve the same amount of meaning while taking up far less "space" in a model's memory, and they give systems background slots for less-active memories — the way a person remembers yesterday clearly but last month only in broad strokes.
Details and caveats. The authors explicitly compare the approach to human memory, and also use the model itself as a training-data factory built from scanned pages. Commenting on the work, Andrej Karpathy noted that images as input for language models might turn out to be more efficient than text tokens. But this is early-stage work: it still needs to be tested for how visual encoding affects reasoning and dynamic forgetting, and the next step is to move from "storage" to actually using visual tokens within the reasoning process itself.
IBM Granite 4.0 Nano: When Small Is the Right Call
IBM released the Granite 4.0 Nano family: open models ranging from a few hundred million to a billion and a half parameters that actually run on laptops and even in a browser. These aren't just "trimmed-down" weights from a bigger model — they're distinct architectural choices (a hybrid SSM-transformer design in the H series), optimization for low latency, and tooling for local deployment.
Why it matters. The industry is moving away from the "bigger is better" metric. Granite Nano offers a different formula: sufficient performance at low memory consumption, an Apache 2.0 license, and compatibility with familiar local-deployment tools like llama.cpp and vLLM. For a business, that translates into three words: private, cheap, fast.
Practical takeaway. In IBM's benchmarks, the models deliver competitive results for their size on instruction-following and function calling, and the company has published fine-tuning recipes for custom tasks. Ticket classification, document tagging, extracting fields from invoices, first-line support — all of this can be handled locally, with no external API, full auditability, and no data ever leaving your premises.
Microsoft 365 Copilot: An App Builder for Every Employee
Microsoft added App Builder and Workflows to Copilot: a Microsoft 365 Copilot subscriber describes a task in plain language, and Copilot generates the interface, a database built on Microsoft Lists, and the logic — all within corporate security policies. That means a department head, not IT, can now build an app to track their team's requests.
Significance. Microsoft cites a hundred million Microsoft 365 users — a scale at which even a small percentage of "self-builders" changes how work gets done: local improvements stop waiting in the IT queue. There's also a migration path to Power Platform for when a project grows from a toy into a real system.
Risks. App Builder gives admins visibility into every app that gets created, but "shadow IT" doesn't disappear — it just becomes visible. Who's going to maintain a hundred apps built in one evening? Success depends not on the tool, but on the rules: what employees can build themselves, what they need to run past IT, and what's off-limits entirely.
GitHub Agent HQ: One Dashboard for Many Coding Agents
GitHub introduced Agent HQ, an attempt to become the "dispatcher" for development agents from various vendors: Anthropic, OpenAI, Google, and others. The idea isn't to replace those tools, but to manage them in one environment using familiar primitives: git, pull requests, CI.
Why it matters. At a large company, several teams are often experimenting with different agents at the same time, and nobody sees the full picture. Agent HQ introduces centralized permissions, auditing, isolated execution environments, and version control for agent behavior through AGENTS.md files in the repository. The Mission Control dashboard shows what every agent is doing; agents get limited tokens and access only to approved branches; there's integration with the MCP protocol and agentic code review powered by CodeQL. A company can test several vendors in parallel and gradually weave agents into development — without ending up in a situation where an agent on someone's machine merges unreviewed code into main.
Intuit: Financial Agents Built Around Trust
Intuit launched Intuit Intelligence, an orchestrator of specialized agents for QuickBooks built around critical financial scenarios. The core idea: don't substitute generated content for real data — build a query layer over the actual data and leave humans in control at key decision points.
Value. In finance, a mistake is expensive, and even a noticeable jump in model accuracy doesn't automatically restore trust. That's why Intuit is betting on a "query against real data" architecture and explainability: the interface shows exactly why the system reached a given decision.
Business takeaway. The agents query a unified data layer and return results as database operations rather than generated text, with human confirmation at key points. For sensitive data, the architectural choice of "query instead of generation" matters more than any demo. It's the same logic I apply in my own automations: the model doesn't make up numbers — it formulates a query to the system where those numbers actually live.
OpenAI Open-Sources Safety Model Weights
OpenAI released a research preview of the gpt-oss-safeguard family — open models for custom content classification. The distinctive feature: the model interprets safety rules at inference time rather than baking a rigid rule set into its weights. You write a policy in plain text, and the model applies it to content and explains its reasoning.
Benefit. Policies can be updated without retraining, the reasoning chain is visible, and corporate rules — what's publishable, what counts as spam, which tickets need escalation — get baked directly into the processing pipeline.
Caveat. Both models (a larger one and a more compact one) are available under Apache 2.0 on Hugging Face. This is a tool for developers, not a ready-made moderation system: its reliability depends on the quality of your own rules and test sets.
What a Business Owner Should Take from This
Three things converged in this single wave of news: resource efficiency (visual tokens, small models), embedding AI into everyday work (Copilot, Intuit), and systematic control over agents and safety (GitHub Agent HQ, OpenAI's safeguard). This isn't one giant trend — it's a set of complementary shifts, and each one has a practical angle for a business of any size.
| Trend | What's Changing | What to Do This Month |
|---|---|---|
| Compact models | Routine tasks no longer need the cloud | List the tasks where data shouldn't leave your premises, and try a local model on one of them |
| Context compression | Long conversations and agents get cheaper | Count how many tokens in your prompts are wrapping versus actual meaning |
| Apps built in plain language | Employees build their own tools | Write the rules: what can be self-built, what needs IT review |
| A dashboard for agents | Agents become governed instead of unruly | Add a rules file for agents to every repository |
| Query instead of generation | The model asks the system instead of guessing | Ban the model from "recalling" numbers in financial and accounting scenarios |
| Policies as text | Safety rules update without retraining | Write down, in plain text, what counts as unacceptable content or requests for you |
If you're adopting AI, decide ahead of time where you need local control and privacy, where the cloud is good enough, and which processes are ready for a "regular employee" to start building their own tools. That's a strategy, not just a pile of experiments. If you need an outside perspective on your business, a 60-minute consultation will turn this into a plan with concrete steps.
The Short Version
- DeepSeek is experimenting with visual tokens: the same context in far less memory; the approach is early-stage, but the direction is serious.
- IBM Granite 4.0 Nano brings open, small Apache 2.0 models that run locally: private, cheap, and fast for routine tasks.
- Microsoft 365 Copilot lets employees build apps using plain language; the real risk isn't the tool, it's the absence of rules.
- GitHub Agent HQ turns coding agents into a governed system with permissions, auditing, and rules stored in the repository.
- Intuit offers a model for sensitive data: the AI queries real data instead of generating an answer.
- OpenAI's gpt-oss-safeguard lets you write a safety policy in plain text and apply it without retraining.
- The common thread is accessibility and control: fewer resources, more governability.
Frequently Asked Questions
Should a small business even bother with local models?
Yes, if you have tasks involving data that can't leave your premises: customer inquiries, documents, financials. Small models can handle classification, field extraction, and first-line support on an ordinary laptop. For complex reasoning, cloud models are still stronger for now — which is why the right setup is a hybrid one.
What does "query instead of generation" mean, and why does it matter?
It's the principle where the model doesn't answer "how much did we earn in March" from memory, but instead builds a query against the database, retrieves the number, and shows it along with its source. That way, the model can't "make up" a figure, and the human can see exactly where it came from. In finance, accounting, and medicine, this is the only acceptable way to work with AI.
How do you prevent chaos once employees start building their own apps?
With rules that come before the tool, not after. Three lists: what employees can build on their own, what needs sign-off from someone responsible before launch, and which data self-built tools should never touch. And a monthly review of everything that's been created — promote the good solutions to a company-wide level, and retire the dead ones.
Why put a rules file for agents in the repository?
Because an agent, like a new hire, only works as well as the instructions it's given. A file in the repository makes those instructions version-controlled, shared across every agent, and visible to the whole team — the cheapest way there is to make agent behavior predictable.
