Summary We are not “automating” in the age of AI. We are delegating. The difference is not semantics; it changes how we design, govern, and measure value. This essay proposes a vocabulary and a practical charter for building agentic systems that deliver outcomes responsibly, drawing on the nuance embedded in Arabic and especially around the idea of وكالة (agency).
Language sets the frame
It’s often claimed that Arabic has far more lexical nuance than English. Whether or not raw counts are comparable, Arabic’s root‑and‑pattern structure undeniably produces families of words that precisely encode roles, intents, and relationships. Around agency alone we have وكالة (agency), موكِّل (principal), وكيل (agent), تفويض (delegation), توكيل (entrustment). This is a useful lens for AI: the words we use either sharpen or blur the reality we’re building.
Why “automate” misleads
“Automate” describes a world of certainty. We predefine the steps, and the machine executes them. Success equals conformance.
Agentic AI is different:
* It perceives messy inputs (language, images, logs) and resolves ambiguity.
* It reasons with goals and constraints that can conflict.
* It adapts to context and learns from feedback.
* Its behavior is probabilistic , not perfectly repeatable.
Calling this “automation” pushes teams toward brittle flowcharts and premature standardization. It also masks the need for oversight and accountability , because we instinctively under‑govern anything we think is “just a script.”
Why “use case” narrows our vision
“Use case” comes from software requirements. It focuses attention on how a tool is used, not on whether value is achieved. In AI, the right question is not “Where does this tool fit?” but “What is the recurring outcome we will reliably achieve under uncertainty, and at what risk and cost? ”
That shift from use case to value case sounds small but triggers different work:
1. Define the outcome (e.g., 3‑day supplier payments with minimal fraud).
2. Map the mission thread (the end‑to‑end sequence across data, policies, decisions, and handoffs).
3. Quantify value (efficiency, effectiveness, experience, and risk).
4. Decide authority (what the agent may do alone vs. with approval).
5. Establish assurance (testing, monitoring, auditability).
A better verb: delegate
Delegate is the right verb because it forces a principal–agent mindset:
* Principals set goals and guardrails.
* Agents act within those limits to achieve the goal.
* Accountability and auditability are designed in from the start.
In some contexts, you’ll also want orchestrate (coordinating multiple agents), commission (to formally authorize), or steward (to maintain and improve over time). But delegate is the everyday word that re‑wires teams to build the right thing.
The WAKALA Charter: operationalizing delegation
Every AI agent should have a WAKALA Charter ; a compact, living contract:
* Work (Outcome): “Maintain a 72‑hour pay cycle for approved invoices with ≤0.1% fraud.”
* Authority : “May read ERP records, send info‑requests, draft payment batches; must seek approval for payments >$50k or anomalies.”
* Knowledge : “Access to ERP, supplier master, sanctions lists; model X for anomaly detection; accuracy thresholds Y.”
* Accountability : “Owner: AP Manager; OKRs: on‑time payments, exceptions resolved, fraud alerts.”
* Limits : “No external emails without template; no changes to supplier banking without dual control; adhere to privacy policy Z.”
* Assurance : “Daily playbacks of 5 random cases; drift monitors; versioned prompts; kill‑switch; quarterly bias review.”
This is small enough to fit on one page and specific enough to run an audit.
From “automation” to an agentic ladder
You can still keep a maturity model; just rename the rungs:
1. Scripted automation : deterministic rules, RPA, glue code.
2. Assisted intelligence : copilots that suggest, humans decide.
3. Delegated agents : bounded authority, measurable outcomes.
4. Orchestrated agency : multiple agents coordinating across mission threads.
5. Managed autonomy : agents negotiate goals and constraints within a governance fabric.
Each step requires sharper WAKALA elements—especially Authority, Limits, and Assurance.
Metrics: measure value, not tool usage
Replace “number of use cases” with:
* Effectiveness : target outcome achieved? (e.g., payment timeliness, permit backlog)
* Efficiency : time/cost per outcome
* Experience : satisfaction, effort score
* Risk : controlled variance, safe‑fail rate, audit pass rate
These metrics align principals and agents—and make trade‑offs explicit.
Governance that fits the words
If you still say “automation,” you’ll under‑invest in assurance because scripts don’t need it. If you say “delegation,” you naturally build:
* Design reviews around WAKALA charters.
* Authority catalogs (what each agent can do).
* Telemetric playbacks (how it reasoned).
* Human courts of appeal (clear escalation paths).
* Versioned behaviors (prompt/model changes under change control).
This is how agentic systems stay safe and useful at scale.
Closing thought
Arabic gives us a vocabulary where agency is explicit and entrustment is formalized. That’s the mindset we need for AI. Stop asking, “What can we automate?” Start asking, “What outcome will we delegate to an agent—and under what authority, limits, and assurance?” The work (and the value) will follow.
Ready-to-use template
WAKALA Charter — 1‑page
* Agent name & owner:
* Work (Outcome & target):
* Authority (autonomy & approvals):
* Knowledge (data, tools, models, thresholds) :
* Accountability (OKRs/SLAs) :
* Limits (ethical/legal/financial/ops) :
* Assurance (testing, monitoring, audit, rollback) :