The current enterprise Agent craze feels a bit surreal.
Gartner expects that by 2028, one-third of enterprise software will have built-in agentic AI, but before 2027, over 40% of agent projects will be cut — the reasons are simple: uncontrolled costs and vague business outcomes. (Reuters)
On the other hand, AWS re:Invent is discussing 'using AI Agents to elevate enterprise automation to a new dimension', with full-chain automation from development, operations to business processes. (Forbes) Microsoft is promoting the Agent Factory guide, teaching you how to mass-produce and schedule enterprise-level Agents. (Azure) Here in China, the term 'AgentOps' has been systematically discussed by teams from the Chinese Academy of Sciences and Tsinghua University — how to treat Agents as production systems for operations. (Tencent News)
The issue is—
When a company truly has dozens or even hundreds of AI agents,
Every day they are adjusting APIs, purchasing services, opening subscriptions, pulling data,
Who pays them? Who budgets for them? Who helps them with reconciliation?
Today, most Agents are just holding a digital version of the corporate credit card:
Log in to a bunch of SaaS using API Keys and OAuth;
On the billing end, all the CFO and FinOps see is a rough aggregate of 'some cloud provider / some SaaS costing thousands monthly';
On the security team’s side, it's even worse—Trend Micro has already warned that 'agentic AI is being used for automated phishing, scams, and intrusions', even new terms like 'vibe crime' have emerged, and the attacks are fully automated running on chain. (IT Pro)
To put it bluntly, most AI agents in enterprises today are in a state of **'unlimited interns + corporate credit cards'**:
They can work, but spending is chaotic, responsibilities are unclear, and records are poor.
Kite's ambition is to compress this chaotic account into its dedicated payment chain designed for Agents.
I. Kite: Extract the 'money line' from AgentOps separately
Let's clarify the issue a bit more.
Enterprises now engaging in Agents typically follow this path:
Business departments want an 'AI sales assistant', 'AI legal assistant', 'AI DevOps helper';
Technical teams leverage MCP, Agent Frameworks, and various toolchains to build a 'running' intelligent agent in just a week or two; (Azure)
Each Agent needs to connect to a plethora of APIs: CRM, ERP, work order systems, cloud resources, payment gateways;
Money is the easiest line to overlook:
Costs are not broken down finely
Only seeing total cloud bills and total SaaS bills, it’s hard to clarify:
'Which Agent actually spent how much money? Is it worth it?'
Authority definitions are unclear
Which interfaces Agents can call and how much budget they can spend is mostly written in configuration files and internal systems;
Once abused or compromised, it's difficult to make precise damage control at the 'money level'.
Difficulties in auditing and accountability
What compliance needs to see is:
'Who approved this Agent? How much authority does it have? Which expense should be allocated to which cost center?'
Kite’s entry point is:
On the AgentOps chain, pull out 'the money line' and create a neutral, auditable Agent payment settlement chain. (Gokite)
You can imagine Kite as:
'A multidimensional wallet + budget control panel + audit ledger for all AI Agents in the enterprise',
Only these three things are integrated into one chain.
II. Kite's solution: Let every Agent come to work with 'on-chain budgets and pay slips'
So what does Kite actually need to solve? In one sentence:
Let AI agents operate in enterprises 'with budgets in hand',
All expenses are closed loop on Kite's on-chain ledger.
Relative to today's state, there are three changes:
Agents are no longer just 'scripts that can call interfaces', but are 'economic entities' with on-chain identities and budget limits.
Budgets, whitelists, and risk control strategies are not written in some internal system, but are written into the state on the Kite chain.
Every expense can be matched with 'which Agent, which business, which strategy'.
In this scenario:
Microsoft / AWS / self-developed Agent frameworks are responsible for **'the brain and behavioral logic'**; (Azure)
Kite is responsible for **'money and permissions'**:
How much can this Agent spend in a day?
Which types of suppliers can be paid?
What to do when exceeding limits?
This is the segment Kite is capturing in AgentOps:
Transforming payment and budgeting into Agent-native foundational infrastructure. (Gokite)
III. Kite's mechanism: Enterprise version 'Agent Identity Matrix + Budget Constraints + Payment Channels'
According to SOP, we break down Kite's mechanism into three parts, all revolving around 'how corporate Agents spend money'.
1) Kite's corporate identity matrix: separate 'people, Agents, conversations' for recording
In enterprises, when an Agent wants to spend money, at least three parties are involved:
Who is the final responsible party? (Company / Department / Project)
Which specific Agent is executing?
Which session/task triggered this expense?
Kite's three-layer identity design essentially separates these three:
User (enterprise / department / project)
is the owner of the funds;
Decide which Agents can spend from which budget pool;
Corresponding to CFO/department heads' perspective of 'cost centers'.
Agent (the agent identity on Kite)
Corresponding to a specific function AI assistant, such as 'Legal Agent' or 'Data Analysis Agent';
Bear the 'executive power', have their own budget limits and whitelist suppliers.
Session (task/conversation)
Each specific task: an automated test round, a batch of contract reviews, a marketing campaign;
Generate fine-grained billing segments for 'how much this task consumed' per instance.
Using Kite to illustrate, a corporate Agent becomes a network of relationships like this:
The significance of Kite lies in:
Money only comes out of the User's budget pool, but every penny can be meticulously allocated to a specific Agent or Session;
Decision-makers can see 'which Agent is burning money, and on which tasks'.
2) Kite's programmable budget constraints: writing GRC/risk control into on-chain rules
Today, enterprises do budgeting and risk control, with a lot of logic hidden in:
Internal financial systems;
Approval processes (emails, work orders);
The security department's own policy engine.
Kite's idea is to write some key constraints onto the chain, requiring Agents to pass this check when spending money:
For each Agent, you can set:
Daily / Weekly / Monthly budget limits;
Maximum amount per transaction;
Allowed supplier and API range (whitelist);
Must include business tags (which project, which cost center).
For each budget pool (User dimension), you can set:
Total budget limit;
Risk levels and approval thresholds (how much exceeds requires secondary approval);
Whether to allow Agents to access certain high-risk resources.
Once these things are written into the state on the Kite chain:
Every time an Agent initiates a payment through Kite, the contract is automatically checked against the budget and policy;
Calls exceeding the rules will be directly rejected or marked for 'manual approval';
All failed attempts also serve as security signals, becoming incidents consumable by SOC/SIEM.
For concerns like 'agentic AI being used for attacks', Kite's defense line is:
Even if a certain Agent's 'brain' is compromised,
On the 'money chain' of Kite, it still cannot escape the budget and whitelists. (IT Pro)
3) Kite's payment channel: breaking down corporate bills into 'auditable micropayments'
The biggest characteristic in the Agent scenario is: extremely high call frequency and extremely low amounts.
DevOps Agents may call APIs tens of thousands of times a day;
Sales Agents may automatically trigger hundreds or thousands of data queries;
If every transaction goes on-chain, the costs and delays are unbearable.
Kite uses a 'payment channel designed specifically for Agents':
First, lock a portion of the budget from the User's budget pool into a channel for a specific Agent;
Agents make high-frequency small payments to various suppliers within the channel;
Write back to the Kite chain only when the channel is opened, closed, or a dispute occurs;
The channel status is always bound to 'budget constraints' and 'identity matrix'.
A simplified flowchart can represent Kite's position in the enterprise:
graph TD
CFO[Finance / Cost Center (User)] --> Budget[Kite Budget Pool]
Security[Security / Compliance] --> Policy[On-chain Constraint Policy]
Budget --> Channel[Agent Payment Channel]
Policy --> Channel
Channel --> Vendor[Cloud Services / SaaS / API Suppliers]
Channel --> Log[On-chain Audit and Reporting]
The result is:
Externally, vendors only see a 'high-frequency settlement channel from Kite';
Internally, enterprises can match every expense with 'which Agent / which Session / which project'.
IV. The triple impact brought by Kite: changes in perspectives for developers, CFOs, and security teams
1) For developers: Kite transforms 'Agents calling money' into a standard interface
Now, when developing a corporate Agent, developers need to have a lot of things in mind:
Different cloud providers and SaaS billing methods;
Various internal approval processes and budget constraints;
The psychological shadow of being 'invited for coffee' by the security team.
If using Kite as the underlying ledger:
Developers only need to call a standardized Kite payment interface;
All budgets and permissions are managed by Kite + corporate policies;
During development, budget overruns and permission denials can be simulated, making Agent behavior more predictable.
For those who truly understand engineering, this means: the 'money' line of the Agent can be abstracted from business code and handed over to Kite to create a unified middleware layer.
2) For CFOs / FinOps: Kite turns Agents into 'measurable cost centers'
Gartner says that a large number of agentic AI projects are to be cut, largely because: it's unclear how much money is being made or spent on this thing. (Reuters)
Kite's on-chain ledger allows CFOs/FinOps to see:
How much has each functional line's Agent consumed in total;
Which Agents' 'cost/output ratios' are positive;
Which look cool but are actually just 'pseudo Agents' frantically calling APIs in the background.
More importantly:
Budgets are no longer just Excel spreadsheets, but are written on the Kite chain;
Once a business line decides to reduce production or cut a project, simply tightening the corresponding budget pool will naturally 'starve' the related Agents.
Kite transforms the power to 'cut Agent projects' from technical assessment into a decision that can be quantitatively discussed by finance and business. (Gokite)
3) For security and compliance: Kite serves as the 'money route defense line' in Agent offense and defense
Trend Micro clearly states its core view when discussing 'vibe crime' and agentic AI automated attacks:
Attacks will become increasingly automated and chain-like, and enterprises need to use their own AI to defend. (IT Pro)
In this context, Kite provides a very realistic line of defense for security teams:
No matter how fierce the attack on Agents is, it ultimately has to come down to the level of 'money'—either buying resources, renting computing power, or purchasing data;
As long as all these 'money routes' go through the Kite chain, the security team can:
Implement hard cuts at the budgeting level;
Create behavioral profiles at the on-chain log level;
Provide clear 'attack paths' and 'loss ranges' during the audit phase.
For compliance, in the future, whether it’s financial report disclosure, internal audits, or external inspections,
A single sentence is enough to explain Kite's value:
'All our expenditures triggered by Agents have traceable identities on Kite, verifiable budgets, and replayable behaviors.'
V. Kite's chip position in the enterprise agent cycle
Ultimately, it comes back to the issues of cycles and positions.
There are many voices around agentic AI now:
Some say it is a 'new generation enterprise automation engine'; (Forbes)
Others warn that most projects will be cut by 2027. (Reuters)
In this line, Kite's position is very clear:
Not to compete in the narrative of 'whose Agent is smarter';
Not competing with cloud providers and model providers for that layer of PaaS/SaaS;
But rather to anchor itself on 'the money line in corporate AgentOps.'
If within the next 2-3 years:
Companies are really moving towards 'large-scale Agentization',
CFOs, CISOs, and compliance begin to seriously discuss 'budgeting for Agents' and 'making Agents auditable',
In the entire tech stack, there will certainly emerge one or two infrastructures dedicated to 'Agent payment and budget ledgers'.
What Kite wants to do is that line:
Understanding how Agents operate and daring to record the company's money on its own ledger.
It may not be the loudest chip in this round of agentic AI,
But if you agree with the logic that 'enterprises will eventually pay AI agents, budget, and audit',
Then a chain like Kite, specifically designed for Agent payment and budgeting,
Would naturally appear on your observation list—
Not for any other reason, but because money and risk control are never absent in a true infrastructure cycle.
