Bf pic
Bf pic
Share
01.11.2025
23
9 min
4.9
★
★
★
★
★
(3)

AI Under Control: Visual Tokens, Nano Models, and Agents

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. The goal has shifted from "more parameters" to "fewer resources for the same result," and from "replace the human" to "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 matters mainly 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, much like 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. Each model is more than "trimmed-down" weights from a bigger one: it has its own 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. At that scale, 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 on the rules more than on the tool: 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 tools stay the same, and they get managed in one environment with 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 bring agents into development without ending up in a situation where an agent on someone's machine merges unreviewed code into main.

The same principle of governed agents works for a website. NEO has a built-in MCP server (Craft CMS 5.12): you connect Claude, ChatGPT or Cursor through OAuth and choose the access level yourself.

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: build a query layer over the actual data instead of substituting generated content, 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 are stored.

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) go 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). Together they form a set of complementary shifts rather than one giant trend, and each one has a practical angle for a business of any size.

TrendWhat's ChangingWhat to Do This Month
Compact modelsRoutine tasks no longer need the cloudList the tasks where data shouldn't leave your premises, and try a local model on one of them
Context compressionLong conversations and agents get cheaperCount how many tokens in your prompts are wrapping versus actual meaning
Apps built in plain languageEmployees build their own toolsWrite the rules: what can be self-built, what needs IT review
A dashboard for agentsAgents become governed instead of unrulyAdd a rules file for agents to every repository
Query instead of generationThe model asks the system instead of guessingBan the model from "recalling" numbers in financial and accounting scenarios
Policies as textSafety rules update without retrainingWrite 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 gives you a strategy instead of 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.
  • In Microsoft 365 Copilot, employees build apps using plain language; the real risk is 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.
  • With OpenAI's gpt-oss-safeguard, 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, so 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. It's the cheapest way there is to make agent behavior predictable.

Ihor Nikolenko
About the author
Founder of DigitTime, author of the D.N.A. Launch Model

In professional digital since 2008: digital marketing and launches. The visionary behind the NEO platform, the Evolve.Place academy and DigitTime Projects. Writes about what he has tested on his own projects, not retold cases of others.

All articles by the author →
The club’s Telegram channel: systems that sell
Short breakdowns, tools and launches — no fluff. One or two posts a week, no spam.
Join on Telegram
Gift
Stay in the loop
© 2026 DIGITTIME LLC · company code 46529302