Introducing Qoni — managed infrastructure for AI agents in production.

A question worth answering properly

Models get smarter every generation, and more teams are building agents than ever. Getting a demo running takes an evening now; the hard part is what comes next. So this piece tries to answer one question properly:

What does it take to build a production-grade agent?

Writing the core business logic is only the start. To send an agent into production and have it work reliably, three more things are missing.

First: an identity of its own

Account systems were designed for people, and agents still have no seat in them. So most agents today borrow a human's identity to get things done: an employee's API key, a shared password. Nobody minds in a demo; in production it's three questions in a row: when something goes wrong, was it the person or the agent? It only needed to do one thing — why does it hold everything this user can do? And what, exactly, allowed this call — a question no log can answer.

And there's a deeper issue: the smarter and more capable the model, the larger the blast radius. The stronger the intelligence, the more it needs boundaries.

Give the agent a clear identity of its own — independent of any human — and the benefits are concrete: every action is attributable, and to whom; every permission is revocable (grants work like visas — scoped and time-boxed); every record is auditable, and reconciled with human identity in one system.

The agent stops being a shadow with borrowed papers, and becomes an employee with a badge.

Second: a productivity tool, and a runtime where it can act

An agent that can only talk isn't productive yet.

Human productivity lives in browsers, operating systems, applications. Agents are no different — an agent needs a browser and a runtime of its own, so it can plan and act autonomously: open pages, fill forms, verify results, retry on failure.

That's when an agent starts producing like a person: not just helping someone think, but doing it for them.

Third: memory, layered and long-term like a human's

A production-grade agent must also understand the people who use it.

Human memory is layered: things that just happened, patterns worked out over time, preferences that are hard to put into words. And people remember what someone did, not just what they said. During sleep, the day's experiences even get sorted — one wakes up with an extra layer of insight.

Agent memory should work the same way: processed in layers rather than logged as a transcript, covering behavior as well as conversation — and ideally able to dream: digesting experience in idle time into deeper understanding.

These three things are Qoni

Today, Qoni makes its official debut.

As managed infrastructure for AI agents in production, Qoni builds identity → action → memory once, integrated into one cloud-hosted runtime. Wiring up a workable identity, running a browser, storing some memory — none of it is hard. What's hard is making those three things secure, reliable, and proven in production. That second part is what Qoni does: a secure, governed, bounded environment that amplifies the model's intelligence safely, makes building agents faster, simpler, and cheaper, and lets agents stand on the web as first-class citizens — with their own identity, actions, and memory. It's a continuation of Tim Berners-Lee's line: this is for everyone.

01 · Identity — GenAuth

Thirty years of identity technology, five generations of protocols — from AD/LDAP and Kerberos to SAML, OAuth 2.0, and OIDC — have all answered the same question: why should this new actor be trusted? The subject was always a human.

Now it's the agent's turn. Researchers break the attribution layer of agent infrastructure into three questions: Agent IDs — who is this agent; identity binding — which person or organization stands behind it; certification — can its behavior and properties be trusted.

GenAuth turns those three questions into a product: every agent gets a passport — an independent Agent ID. Every action is attributable to the delegator. The delegated authorization chain runs on the existing rails of OAuth 2.0 / OIDC — short-lived credentials whose scope only narrows, never widens. MCP tool calls fall under the same governance. All of it, one SDK away.

Four core principles: predictable, governable, revocable, traceable.

Security engineering calls this narrow-only design the principle of least privilege: the closer permissions track what needs doing right now, the more predictable the behavior. Identity technology has traveled thirty years; this time, at last, the subject is the agent.

02 · Action — Web Agent

For humans and agents alike, almost 90% of productivity happens on the web, in a browser.

Give an agent a browser, and typical browser-use setups turn out slow, expensive, and not accurate enough. Fine in a demo, scary in production. Web Agent's answer is hosted execution: the agent's entire loop — observe, decide, act, retry — runs in the cloud, with no browser to maintain.

Every capability ships as an API:

• DoAnything — one sentence, a full multi-step web flow: the page is re-observed after every step before the next move; success is never self-reported, only the visible end state counts. Every run is recorded and replayable.
• WebSearch — not one search, but a round of verification: multiple engines in parallel, sources cross-checked — structured, citation-backed results returned.
• DeepResearch — turns "looking things up" into "delivering a report." A brief and outline first, direction confirmed before large-scale collection; then cross-checking and synthesis into a document with citations and confidence labels.
• Track — watches pages; "did it change" is never a feeling. Change is decided by deterministic rules; the moment it does, a webhook lands in the downstream system.

Add reusable login profiles on top: sign in once, and later tasks carry the state.

"Fast and accurate" is an engineering bar Qoni sets for itself: P90 task completion within two minutes, success rates pushed toward 99%, ground out by replaying real tasks round after round until it holds.

Two example scenarios: social-media publishing, comment monitoring, competitor tracking, public-data aggregation; and enterprise legacy systems with no API, brought back within reach through the browser.

When a step needs a human — a login, a QR code, a CAPTCHA — the agent hands over the browser: the operator finishes that step, and the agent resumes from the breakpoint, task unbroken, context intact.

03 · Memory — GUMem

The industry has reached consensus: an agent without memory meets its users for the first time, every time. But most "memory layers" only do half the job — extract the chat, store it, search it back later.

GUMem does the other half too:

• Two tracks: conversation and behavior. Not just what users said, but what they did — what they clicked, chose, abandoned. Behavior is often more honest than words.
• A multi-layer memory pipeline. Conversations → facts → summaries → topics, distilled layer by layer — the higher the layer, the closer to who this person is. Every memory carries its source, confidence, and time decay.
• Recall that plans. A query agent breaks the question apart, gathers evidence across memory types, and assembles just enough context — and when the evidence runs out, it says so instead of guessing.
• AutoDream insights. In idle time, GUMem digests accumulated behavior into deep, personal insights — "tends to order late at night," "has been watching Tokyo flights for three weeks." Not a pre-built report: the agent decides what to analyze, writes its own code, and runs it to a conclusion.
• Formation in plain view. Memories don't grow in a black box: each one's distillation from conversation and behavior can be observed in real time — like watching it take shape.

And all of it belongs to the user: visible, editable, deletable. Memory belongs to the user, not the model. On LoCoMo, a long-conversation memory benchmark, GUMem scores 92.9% — the score is public on Qoni's site.

From one agent to a hundred

When every agent has an identity, a permission boundary, and a full audit trail, something changes: running one agent inspires confidence, and so does running dozens — even hundreds — each doing its own work. If anything goes wrong, it can be traced and stopped, instantly.

The bigger the fleet, the safer and more controllable it gets.

Safer. Stronger. Yours.

When an agent has a soul

In the coming years, the web will be home to agents in the hundreds of millions. They'll book the trips, watch the markets, run the workflows — a real share of the world's work, done on people's behalf.

That world can take two shapes. One is chaos: countless nameless automations charging around on borrowed identities, no one sure who is doing what. The other is order: every agent with a name, a boundary, and a place it came from — brilliant, and worthy of trust.

Qoni is building the second one.

"Give your agent a soul" isn't a romantic line. It's literal: an identity, so it can be recognized. Boundaries on its actions, so it can be trusted. A memory, so it can be entrusted. A soul is everything "trustworthy" means.

Tim Berners-Lee said: this is for everyone. Qoni wants to carry that sentence one step further —

The Agentic Web should be for everyone, too.

Now

Qoni is in private build.

Join the waitlist on the website — one email when it opens. Nothing else.

Give your agent a soul.