Sika

SIKA is an autonomous financial agent that monitors Mobile Money activity, understands transactions, answers requests, and takes actions with human confirmation when required.

Comment

SIKA — Autonomous Personal Financial Agent

Inspiration

Mobile Money has become an essential part of everyday financial life in Côte d'Ivoire and across West Africa. People use digital wallets for transfers, payments, withdrawals, savings, and daily expenses.

However, having multiple digital wallets does not necessarily mean having better control over personal finances. Users still need to manually check balances, remember transactions, understand where their money is going, and make financial decisions without intelligent assistance.

We wanted to build something different from a traditional finance dashboard.

Instead of creating another application that simply displays financial data and charts, we imagined SIKA: an autonomous personal financial agent capable of understanding a user's financial situation, reasoning about it, using specialized financial tools, and helping the user act safely.

The idea behind SIKA is simple:

Don't just show people their money. Give them an intelligent agent that understands their financial context and helps them make better decisions while keeping them in control.

What it does

SIKA is an autonomous personal financial agent designed to understand, analyze, and assist with a user's financial activity.

Rather than acting as a passive dashboard, SIKA can inspect financial information, build financial context, use specialized tools, reason about the user's objective, and prepare actions when appropriate.

Core capabilities Multi-Wallet Awareness — Access and understand information across connected financial wallets. Balance Analysis — Retrieve wallet balances and calculate the user's available financial balance. Transaction Analysis — Retrieve and analyze recent financial activity. Financial Context — Combine balances, transactions, wallet information, and user preferences into a broader financial picture. Contact Search — Identify known recipients before preparing a transfer. Financial Tool Selection — Select specialized tools according to the user's objective. Safe Transaction Preparation — Prepare financial operations without blindly executing them. Human-in-the-Loop Security — Sensitive actions require explicit user approval. Biometric Confirmation — Sensitive operations can require biometric or device-credential validation. Risk-Based Tools — Financial tools are classified according to their risk level. Structured Agent Responses — Tools return standardized results containing status, data, risk information, and confirmation requirements. Voice Interaction — SIKA supports voice interaction through Flutter and native Android capabilities. Multilingual Interaction — The assistant supports French and English across the UI, AI responses, STT, and TTS.

The agent follows an eight-step workflow:

Understand → Inspect → Select Tool → Read → Prepare → Human Confirmation → Execute → Report

This allows SIKA to assist with financial tasks while ensuring that sensitive actions remain under the user's control.

How we built it

We built SIKA as a modular agent architecture that separates mobile experience, agent orchestration, financial tools, security controls, and native Android capabilities.

Backend — FastAPI + Python

The backend is built with Python and FastAPI.

Its architecture includes:

  • An agent orchestrator responsible for coordinating operations.
  • A centralized SikaToolRegistry.
  • A state-based agent workflow.
  • Specialized financial tools.
  • Structured tool contracts and results.
  • Risk-based access control.
  • Human-in-the-loop confirmation.
  • Memory and state foundations.
  • Automated testing with pytest.

Instead of giving the AI unrestricted access to financial operations, SIKA communicates with controlled tools that define exactly what actions are allowed.

Financial Tool Registry

The SikaToolRegistry is one of the core components of the architecture.

Each tool has a clearly defined purpose, input contract, output structure, and risk level.

The current prototype includes tools for:

  • Retrieving wallets.
  • Checking wallet balances.
  • Calculating total balances.
  • Retrieving recent transactions.
  • Analyzing spending.
  • Building financial context.
  • Searching contacts.
  • Preparing transfers.
  • Confirming transfers.

The risk model separates operations into three levels:

  • READ_ONLY
  • CONFIRMATION_REQUIRED
  • EXECUTION

This creates a controlled boundary between agent reasoning and real financial actions.

Human-in-the-Loop Architecture

Sensitive financial operations are handled through an explicit confirmation workflow.

For example:

User request → SIKA understands the objective → Inspects the relevant financial context → Selects the appropriate tool → Prepares the operation → Requests human confirmation → Biometric validation when required → Executes the approved action → Returns the result

SIKA can reason, analyze, and prepare actions, but it is not designed to independently execute sensitive financial operations without user approval.

Partner API Integration

SIKA is connected to the PayMeChap partner API, allowing the prototype to retrieve real wallet information, transaction history, balances, and savings vault data through the financial API infrastructure.

This connection allows the agent architecture to work with actual financial data rather than functioning only as a static interface.

Mobile — Flutter + Native Android Kotlin

The mobile application is built with Flutter and Dart.

The Flutter application includes:

  • The SIKA financial assistant interface.
  • Financial dashboards and insights.
  • Wallet and transaction views.
  • Human confirmation interfaces.
  • Riverpod state management.
  • API communication.
  • Voice and assistant foundations.

Native Android capabilities are implemented with Kotlin.

The Android layer includes services such as:

  • SikaWakeWordService
  • SikaWakeWordServiceV2
  • SikaOverlayService
  • SikaOverlayServiceV2
  • BootReceiver
  • MainActivity
  • Flutter Method Channels

This architecture allows Flutter to handle the user experience while Kotlin provides deeper access to Android capabilities needed for background services, voice interaction, and future system-level perception.

Testing

The financial Tool Registry is covered by automated tests using pytest.

The test suite validates tool discovery, wallet retrieval, balance analysis, transaction analysis, spending summaries, transfer preparation, confirmation flows, invalid arguments, and security restrictions.

The current test suite achieves 100% success.

The Flutter application has also been validated using flutter analyze.

Challenges we ran into

Designing a Safe Financial Agent

One of our biggest challenges was ensuring that an AI agent could work with financial information without having unrestricted access to sensitive operations.

We needed to clearly separate:

  • Information retrieval.
  • Financial analysis.
  • Action preparation.
  • Human confirmation.
  • Final execution.

This led to the development of SIKA's risk-based Tool Registry.

Human-in-the-Loop Design

A financial action cannot be treated like a normal chatbot response.

SIKA needed a workflow where the agent could understand and prepare an operation while the user retained final control.

We introduced explicit confirmation requirements and biometric validation for sensitive actions.

Connecting Flutter and Native Android

SIKA is designed to eventually operate beyond a traditional application interface.

Supporting background capabilities, wake-word interaction, overlays, and future notification perception requires deeper communication between Flutter and the Android operating system.

Building this bridge between Flutter and Kotlin while keeping the application modular was an important engineering challenge.

Keeping the Agent Modular

We wanted to avoid building a monolithic AI service where every new feature required rewriting the system.

The centralized Tool Registry allows new capabilities to be added as independent, controlled tools.

Testing Financial Workflows Safely

Financial workflows need deterministic validation.

We built automated tests around the Tool Registry and its security rules to verify that operations follow the correct contracts and that sensitive actions respect confirmation requirements.

Building the Agent Foundation

Another challenge was building a complete agent foundation rather than simply connecting a language model to a chat interface.

We had to design the orchestration, state management, tools, permissions, confirmation workflow, and mobile architecture so they could work together as one system.

Accomplishments that we're proud of

A Real Agentic Architecture

SIKA is more than a chatbot connected to financial data.

We built an agent foundation with an orchestrator, state management, structured tools, memory foundations, permissions, and controlled execution workflows.

Financial Safety by Design

Instead of giving an AI direct access to financial operations, SIKA uses a centralized registry of typed and controlled tools.

Risk levels prevent sensitive actions from bypassing the required confirmation process.

Human Control at the Center

One of our most important achievements is the Human-in-the-Loop architecture.

SIKA can observe, understand, analyze, and prepare financial actions, but the user remains responsible for approving sensitive operations.

Direct Financial API Integration

The prototype is connected to the PayMeChap partner API, allowing SIKA to access wallet balances, transaction history, and savings vault information.

This gives the project a concrete financial data layer behind the agent experience.

Native Mobile Agent Foundation

We combined Flutter with native Android Kotlin services to create a foundation for capabilities that go beyond a traditional mobile interface.

This prepares SIKA for future background services, wake-word interaction, overlays, and financial event perception.

Automated Validation

The financial Tool Registry achieved 100% success in its pytest test suite, while the mobile project was also validated with flutter analyze.

What we learned

An Agent Is More Than an LLM

One of the biggest lessons from building SIKA is that an AI agent is not simply a language model connected to a chat interface.

A useful agent requires:

  • An orchestrator.
  • State management.
  • Specialized tools.
  • Structured outputs.
  • Permissions.
  • Memory.
  • Error handling.
  • Safety boundaries.

The intelligence of the system comes from how these components work together.

Financial Agents Need Strong Guardrails

Financial AI requires safety at the architectural level.

An AI model should not have unrestricted access to balances, transfers, or other sensitive operations.

Controlled tools, risk levels, and human confirmation must be part of the system design.

Tool Design Matters

Each tool needs a clear purpose, input contract, output structure, and risk level.

This makes the agent easier to test, secure, and extend.

Autonomy Does Not Mean Removing the User

The best role for an autonomous financial agent is not to remove the user from important decisions.

SIKA should understand, reason, inspect, and prepare.

The user should remain in control when an action can affect their money.

Mobile Agents Need Native Capabilities

Building an agent that can eventually perceive events outside a traditional application screen requires deeper operating system integration.

Flutter provides the user experience, while native Android services provide access to capabilities needed for background operation and future system-level perception.

What's next for SIKA

Immediate Roadmap

Our next priority is to connect the existing agent foundation to Google's Gemini models using the Google GenAI SDK and enable intelligent tool selection based on the user's objective.

We also plan to expand SIKA's perception capabilities through Android notification events.

The immediate roadmap includes:

  • Gemini Integration: Connect the SIKA orchestrator to Gemini for reasoning and function calling.
  • Automatic Tool Selection: Allow Gemini-powered reasoning to select the appropriate financial tools.
  • Notification Perception: Implement Android notification listening for relevant Mobile Money events.
  • Real-Time Financial Context: Transform observed financial events into structured information SIKA can understand.
  • Biometric Action Confirmation: Expand the confirmation experience for sensitive operations.
  • End-to-End Agent Workflow: Connect perception, reasoning, planning, tools, confirmation, execution, and reporting.

Medium-Term Goals

  • Detect unusual spending patterns.
  • Develop proactive financial alerts.
  • Improve long-term financial memory.
  • Expand voice interaction and wake-word capabilities.
  • Support multilingual interactions, including French, English, and Nouchi.
  • Expand the financial tool ecosystem.
  • Support additional Mobile Money providers.
  • Deploy and scale the SIKA backend and agent infrastructure using Google Cloud.

Long-Term Vision

Our long-term vision is to make SIKA an intelligent financial assistance layer for Mobile Money users.

Instead of constantly opening multiple applications, checking balances manually, remembering transactions, and analyzing spending alone, users could interact with an agent that understands their broader financial situation.

The future workflow is:

User Objective → SIKA Understands → SIKA Observes Financial Context → SIKA Reasons → SIKA Plans → SIKA Selects Tools → SIKA Performs Safe Operations → SIKA Requests Confirmation When Necessary → SIKA Executes Approved Actions → SIKA Reports the Result

Our vision is simple:

Don't just show people their money. Give them an intelligent agent that understands it and helps them act on it — while keeping them in control.

Built With

Share this project:

Updates

Submission history