Most AI agents today operate using infrastructure provisioned by humans.
A developer creates an account with an AI provider, generates an API key, configures billing and puts the credentials inside an application.
The agent then uses those credentials to interact with the provider.
This architecture works.
But it raises an interesting question:
What happens when AI agents need to provision and manage their own infrastructure?
Imagine building a research agent.
You give it a task:
- Find relevant research.
- Process 5,000 documents.
- Classify the information.
- Generate a report.
- Deliver the results.
The agent can perform most of these tasks, but it still depends on infrastructure that somebody else must provision and manage.
It needs inference access, batch execution, tools, credentials and a way to manage spending.
This is the problem we have been working on at Fikra API.
The problem with giving agents API keys
An API key gives an application access to a service.
However, it does not necessarily provide everything an autonomous agent needs.
Consider some of the requirements:
| Requirement | Why it matters |
|---|---|
| Account provisioning | The agent needs an infrastructure account to operate through. |
| Scoped credentials | The agent should only access permitted resources. |
| Inference | The agent needs models for reasoning and generation. |
| Batch execution | Large workloads should execute asynchronously. |
| Tools | The agent needs to perform actions beyond generating text. |
| Cost estimation | The agent needs to understand expected spending. |
| Usage records | Humans need visibility into infrastructure consumption. |
These requirements suggest a different approach to AI infrastructure.
Rather than simply exposing inference endpoints, we need infrastructure designed around the operational requirements of autonomous agents.
Agent for Humans: A different infrastructure model
We built Agent for Humans (A4H) at Fikra API.
The idea is straightforward.
An agent can provision an account for a human, obtain scoped credentials and interact with the infrastructure through that account.
The account provides access to inference, batch processing and tools.
The human remains able to review and claim ownership.
Here is how the workflow looks conceptually:
Step 1: Provision an account
The agent initiates account provisioning for the human.
Step 2: Obtain credentials
The agent receives the credentials and permissions required to access the permitted resources.
Step 3: Understand execution costs
Before running workloads, the agent can request a quote.
This is important because autonomous agents can generate substantial infrastructure consumption without a human approving every individual request.
Step 4: Execute inference
The agent accesses the available models through Fikra's inference infrastructure.
This enables reasoning, generation, classification and other model-driven operations.
Step 5: Submit batch workloads
For larger jobs, the agent can use asynchronous batch execution.
For example, a research agent processing thousands of documents does not necessarily need to execute every request through a synchronous interaction.
Step 6: Use tools
An agent needs more than model responses.
It needs tools to interact with external systems and perform operations.
Fikra provides tool access through its infrastructure, including MCP capabilities.
Step 7: Maintain human oversight
The account provides usage visibility and records, while the human can review and claim the account.
What can developers build with this?
There are several possible applications.
Research agents
An agent can gather information, submit document-processing workloads and generate reports.
Data processing agents
Agents can classify, extract and structure information from large datasets using batch workloads.
Software development agents
Development agents can use inference and available tools as part of their coding and automation workflows.
Business automation agents
Agents can combine reasoning, infrastructure access and external tools to execute business processes.
These are examples of workflows that developers can build around the infrastructure. The exact capabilities depend on the tools and permissions configured for each application.
Why we think this matters
AI infrastructure has largely evolved around developers and applications.
But autonomous agents are becoming a new type of software participant.
They need to interact with infrastructure, not just consume model responses.
That means infrastructure providers will increasingly need to think about:
- Machine-accessible account provisioning.
- Scoped credentials.
- Programmable spending.
- Asynchronous execution.
- Tool interoperability.
- Auditable infrastructure usage.
- Human ownership and control.
We believe these capabilities will become increasingly important as autonomous agents move from demonstrations into production systems.
Try Fikra API
We are building Fikra API around this direction.
The platform brings together agent-oriented account access, inference, batch workloads and tools.
You can explore the platform and its documentation here:
Website: https://fikraapi.co.ke
Documentation: https://docs.fikraapi.co.ke
MCP endpoint: https://api.fikraapi.co.ke/v1/mcp
We are particularly interested in connecting with developers building autonomous agents, agent frameworks and AI-powered applications.
The question we are exploring is simple:
What would software look like if AI agents could provision and operate their own infrastructure?
That is what we are building towards at Fikra.
Top comments (1)
the quote step before running anything is the part i would keep no matter what. an agent spending money nobody approved per request is where trust breaks first. curious how the human claim step handles an agent that already overspent