You are not deciding whether an AI keyboard can write a polished reply. That part is already becoming ordinary. The harder product question is whether a keyboard can understand enough of the user’s situation to finish a task without becoming intrusive, unpredictable, or dangerous.
The opportunity is real because the keyboard sits at a valuable moment: the user has expressed an intent but has not yet completed it. The product that closes that gap can remove searches, app switches, copying, and repetitive coordination. But it earns that role only by making context use visible and keeping the user in control.
The strategic shift is from text completion to task completion
A conventional predictive keyboard asks, “What word is likely to come next?” A generative keyboard asks, “What text would help this person?” A screen-aware, agentic keyboard asks a more consequential question: “What outcome is this person trying to produce from here?”
That distinction separates three products that can look similar in a demo but create very different obligations for a product team.
| Product layer | What it produces | Typical value | Main failure to manage |
|---|---|---|---|
| Composition assistance | Corrections, rewrites, or suggested text | Faster and clearer typing | The wording is wrong or inappropriate |
| Contextual retrieval | A fact, location, link, document, or recommendation | Less searching and copying | The retrieved item is wrong, stale, or disclosed in the wrong conversation |
| Agentic execution | A state change such as creating a meeting or sending a completed response | The task ends inside the current flow | The system changes something the user did not intend |
Acti illustrates the third layer by putting an agent behind a long press on its space bar. Its documented flow is type, hold, preview, and apply. The keyboard can retrieve information, insert a location, find a document, surface a score, or help create a calendar action without requiring the user to leave the app where the request began.
The strategic value is not “AI everywhere.” It is continuity. The user does not have to suspend a conversation, remember why they left it, complete work in another app, and reconstruct the original message. The keyboard compresses that coordination into one interaction.
This also changes the competitive frame. A standalone assistant competes for visits. A keyboard competes to become infrastructure. That gives it access to more moments of intent, but it also raises the cost of every mistake. Users may tolerate a mediocre chatbot answer. They will not tolerate an unreliable input surface that appears whenever they type.
Key takeaways
- Do not define the product as a chatbot placed inside a keyboard. Define it as a controlled bridge from expressed intent to a completed outcome.
- Separate writing, retrieval, and execution in the product architecture. They have different permission, verification, and recovery requirements.
- Measure coordination removed, not words generated. App switches avoided, successful task completion, and repeat use are closer to the value proposition.
- Treat screen awareness as a permission contract. The user should be able to tell what context was used, why it was needed, and whether anything left the device.
- Start with actions that are easy to preview and reverse. Expand authority only after users repeatedly accept the results and keep the keyboard enabled.
Design the action loop before choosing the model
A strong model cannot rescue an ambiguous interaction contract. Before debating prompts, orchestration frameworks, or model providers, specify how an intent becomes an action and where the user can stop it.
I would design that contract as five explicit stages.
- Invoke. The user deliberately calls the assistant. A long press, dedicated key, or selected-text action is easier to understand than an agent that activates whenever it believes it can help.
- Scope. The interface shows which context will be used: the drafted message, nearby conversation, current location, calendar, or a connected knowledge source. If more context is required, the keyboard asks before retrieving it.
- Generate or plan. The system produces a proposed answer or action. Internal complexity can be hidden, but the intended outcome cannot be.
- Preview and confirm. The user sees the exact text, link, recipient, time, location, or state change before it is applied. A consequential action receives a stronger confirmation than inserting editable text.
- Recover. The user can edit, undo, retry, or open the relevant app to inspect the result. Recovery is part of the core workflow, not an error-state afterthought.
The crucial product decision is where “apply” ends. Inserting a draft into a text box is not the same as sending it. Showing a proposed meeting is not the same as creating one. Finding a document is not the same as sharing it with the current recipient. Each boundary adds convenience, but it also transfers authority from the user to the system.
Use an authority ladder instead of one global automation setting:
- Suggest: show a possible next step without changing the draft.
- Insert: place editable content in the current field.
- Prepare: assemble an action with its parameters visible.
- Execute after confirmation: make the external change only when the user approves the final state.
- Execute under a saved rule: reserve this for narrow, repeatable actions whose scope, limits, and recovery path are already understood.
This structure makes autonomy legible. It also gives your team a safer expansion path: improve suggestions first, then insertion, then prepared actions, and only later consider delegated execution.
Acti’s programmable Skills point to another important design choice. A user can assign a multi-step task to a long press and describe that shortcut in plain English. This turns the keyboard from a generic assistant into a personal intent palette. The benefit is speed; the risk is invisible complexity. A saved skill should therefore display its inputs, connected services, intended output, and execution authority before activation. The user should not have to remember what an overloaded key is permitted to do.
Screen awareness is a permission contract, not a feature label
“Screen-aware” is too vague to guide a security review or earn informed consent. It could mean the keyboard uses only selected text. It could mean it can access surrounding conversation context, live location, calendar data, or connected documents. Those are materially different products.
Replace the label with an operational definition for every workflow. Your specification should answer these questions in plain language:
- What exact data can the keyboard read?
- Does access begin only after an explicit invocation, or can context be collected beforehand?
- Which processing happens on the device, and which data is sent to an external model or service?
- Is context used only for the current request, or is any part retained?
- Which connected accounts can be searched, and which can be changed?
- Can the user inspect and revoke each permission independently?
- What is suppressed in sensitive fields or conversations?
Acti presents its approach as local-first, with personal data staying on the device unless a feature requires outside processing. That is a useful architectural direction, but “local-first” is not a complete privacy explanation. A user still needs to know which features cross the boundary, what is transmitted, which service receives it, and what happens after the request is complete.
Permission should grow with capability rather than arrive as one broad request during setup. A practical progression looks like this:
- Typed-text access: the assistant works only with text the user has entered or deliberately selected.
- Conversation context: the user permits additional visible context for a specific invocation.
- Read access to a service: the keyboard may search a calendar, document store, location service, or another connected source.
- Write access to a service: the keyboard may prepare or execute a state-changing action under explicit controls.
Do not silently move a user from one level to the next because a model could produce a better answer with more data. The request for added context should appear at the moment its value is understandable: “Use your calendar to check availability?” is more meaningful than a setup screen asking for broad calendar access before the user has attempted a scheduling task.
Build suppression into the design as well. Authentication secrets, payment information, confidential company discussions, personnel matters, and regulated records should not be treated like ordinary chat. If the system cannot reliably establish that an invocation is appropriate, the safe behavior is to disable the AI function while leaving normal typing available.
For an enterprise rollout, this permission model becomes part of data governance. Administrators will need control over approved models, allowed connectors, retention behavior, action types, and auditability. A consumer-friendly consent screen cannot substitute for those controls.
Start with bounded workflows that are easy to verify
The first use case should not be the most impressive action the agent can perform. It should be the smallest repeated task where the keyboard has enough context, the result is easy to inspect, and an error is inexpensive to correct.
Evaluate candidate workflows against five conditions:
- Repeated intent: the same need appears often enough for a new interaction habit to form.
- Compact context: the required information can be named and retrieved without granting access to an entire digital life.
- Visible correctness: the user can judge the proposed result from the preview.
- Reversibility: an incorrect result can be edited, cancelled, or undone.
- Observable completion: the product can determine whether the intended task finished, rather than using insertion as a proxy for success.
This creates a sensible workflow ladder.
- Draft and transform. Rewrite, shorten, translate, or change tone while leaving the user responsible for the final send.
- Retrieve and insert. Bring back a document link, sports score, restaurant option, or other inspectable result. Location deserves additional care because inserting an accurate result can still disclose sensitive information to the wrong recipient.
- Prepare a structured action. Fill in a meeting title, time, participants, and conferencing link, then show the complete proposal.
- Execute a reversible action after confirmation. Create the reviewed meeting or save an approved item, with a clear path to inspect and undo it.
- Defer high-consequence autonomy. Financial transfers, account changes, confidential disclosures, and irreversible sends are poor opening bets because a plausible preview does not eliminate their downside.
For the initial product wedge, choose one audience, one recurring intent, and one result format. A broad promise such as “do anything from your keyboard” makes evaluation nearly impossible. A narrow promise such as “turn a scheduling request into a reviewed calendar proposal without leaving the conversation” gives you a clear trigger, required context, success state, and failure policy.
Write the job in the user’s language before building the agent: “When someone asks to meet, I want to check my availability and prepare a complete invitation without breaking the conversation.” Then map every dependency. The keyboard may need the request text, calendar read access, time-zone handling, participant identities, conferencing preferences, and calendar write access. If any dependency cannot be shown or controlled, reduce the promise.
Model choice matters, but it is unlikely to be the whole moat. Acti uses Google’s Gemini models while differentiating through its cross-app surface, invocation design, context layer, and programmable Skills. For your product, defensibility is more likely to come from trusted permissions, reliable connectors, personal workflow configuration, and accumulated evidence that the system completes a narrow job correctly.
Prove the keyboard deserves to become a default surface
A keyboard does not win merely because users install it. It wins when they keep it enabled across ordinary typing, deliberately invoke the AI behavior, accept its proposed outcomes, and return to the same workflows. Your measurement system should follow that chain.
Track the product as a task funnel:
- Enabled: the keyboard remains available after setup.
- Invoked: the user deliberately calls an AI function in an eligible situation.
- Previewed successfully: the system produces a valid result or action plan.
- Applied: the user inserts or confirms the proposal.
- Completed: the underlying job reaches its intended outcome.
- Repeated: the user returns to the same capability in a later situation.
Do not make acceptance rate the sole success metric. A user can accept a draft and then spend more time repairing it than typing from scratch. Pair completion with correction behavior, undo or cancellation, abandonment after preview, connector failures, permission revocation, keyboard disablement, and attempts to invoke AI in suppressed contexts.
The cleanest value test compares the full task, not the generated text. Observe how a target workflow happens without assistance: how many app switches, searches, copies, edits, and confirmations it requires. Then compare the keyboard-assisted path. The product has earned its place when it removes coordination while preserving or improving task accuracy and user control.
A/B tests can improve triggers, previews, permission prompts, and confirmation design, but keep the underlying job constant. Otherwise, a more ambitious variant may appear worse simply because it attempts a harder action. Segment results by authority level as well; inserting editable text and changing an external system should never share one aggregate success rate.
Expand to a new action only when the current one shows repeat use, understandable permission behavior, reliable completion, and manageable recovery. If users regularly hesitate at the preview, revoke a connector, or disable the keyboard after an error, adding more autonomy will amplify the trust problem.
Your next step is concrete: select one repeated cross-app task, write its context and authority contract, prototype the invoke-preview-confirm-recover loop, and test whether it removes real coordination. If the keyboard cannot explain what it read or show exactly what it will change, it is not ready to act. If it can do both consistently, the keyboard may become more than an input method; it can become the user’s controlled layer for turning intent into action.
References








