An autonomous AI Agent for real-time cryptocurrency market information

Client: IQAI Industry: Web3 & Blockchain, AI Role: AI Engineer & Agent Architect Technologies: TypeScript, Node.js, IQAI Agent Development Kit (ADK), Google Gemini, CoinGecko API, CoinDesk API, PNPM, Biome

Crypto AI Agent is a command-line AI assistant that combines Large Language Models (LLMs) with specialized tools to provide real-time cryptocurrency market intelligence directly from the terminal. Built using the IQAI Agent Development Kit (ADK), the agent autonomously interprets natural language queries, determines which external tools to invoke, retrieves live market data and industry news, and generates structured, context-aware responses.

Rather than acting as a traditional chatbot, the agent demonstrates how modern AI systems can reason through multi-step requests, orchestrate multiple APIs, maintain conversational context, and deliver actionable information, eliminating the stress of searching through different forums and news platforms.

The project was built as a practical exploration of agentic AI architecture, showcasing how LLMs can evolve from text generators into intelligent systems that interact with external tools to inform decisions.

Cryptocurrency prices, market capitalization, trading volume, and industry news change by the minute, forcing investors and developers to constantly switch between exchanges, market trackers, and news websites to stay informed.

Traditional chatbots are limited because they generate responses based on previously trained knowledge and cannot reliably answer questions about rapidly changing markets.

The challenge was to build an AI agent capable of:

Understanding natural language requests

Determining which external tools were required

Retrieving live market information

Combining data from multiple sources

Maintaining conversational memory

Delivering accurate, structured responses inside a lightweight terminal interface

The goal was to demonstrate how autonomous AI agents can bridge the gap between reasoning and real-world information retrieval.

I independently designed, architected, and developed the entire AI agent.

My responsibilities included:

Agent architecture design

Prompt and instruction engineering

Tool development

API integration

LLM orchestration

Session management

CLI experience design

Error handling

Response formatting

Rather than hardcoding responses for specific commands, I designed the application around an agentic architecture. Users communicate naturally with the AI agent using conversational language.

The agent analyzes each request, determines which tools are required, invokes the appropriate APIs, processes the returned data, and generates a coherent response grounded in real-time information.

For example, a single request such as: "Show me Bitcoin's current price, market cap, trading volume, and today's most important crypto news."

requires the agent to:

Understand user intent

Invoke the cryptocurrency data tool

Query CoinGecko

Invoke the news tool

Query CoinDesk

Merge multiple API responses

Generate a structured news update in a markdown file

This orchestration happens automatically without requiring the user to know which APIs or tools are involved.

Autonomous Multi-Tool AI Agent: At the core of the project is an autonomous AI agent capable of selecting and orchestrating multiple tools during a single conversation.

Instead of relying solely on language generation, the agent combines LLM reasoning with external APIs to retrieve live cryptocurrency information before constructing its response.

Live Cryptocurrency Market Intelligence: The agent retrieves real-time cryptocurrency information directly from CoinGecko.

Users can request information such as:

Current prices

Market capitalization

Trading volume

Market rankings

General market statistics

Because responses are generated using live API data, users receive accurate information rather than outdated model knowledge.

Real-Time Crypto News: The agent also monitors industry news and developments through CoinDesk.

Users can ask for:

Latest cryptocurrency news

Industry developments

Market events

Technology updates

Regulatory news

The agent summarizes relevant articles into concise reports in markdown format.

Natural Language Conversations: Rather than requiring predefined commands, users ask questions and have conversational interaction with the AI agent. The agent interprets natural language requests and determines how to satisfy them using the available tools.

Multi-Turn Conversation Memory: The application maintains conversational context using ADK's session management system.

This allows follow-up questions such as:

"What about Ethereum?" or "Compare that with Solana." without requiring users to repeat previous context. Maintaining conversational memory creates a significantly more natural interaction than isolated request-response systems.

Modular Agent Architecture: Agent logic, external tools, configuration, utilities, and session management remain independent, making it straightforward to introduce new tools or support additional data providers without restructuring the application.

Agentic AI Architecture: Built with the IQAI ADK TypeScript library that provides the foundation for developing autonomous AI agents capable of reasoning, invoking tools, and maintaining conversational state. This creates a flexible architecture that can easily grow beyond cryptocurrency use cases.

Large Language Model Integration: The reasoning engine and decision-making layer are powered by Google's Gemini 2.5 Flash model. The language model is responsible for:

Understanding user intent

Orchestrating external tools usage

Interpreting API responses

Producing natural-language explanations

Maintaining conversational flow

Custom Tool Development: To provide domain-specific capabilities, I developed two independent tools:

CryptoDataTool to retrieve live cryptocurrency information from CoinGecko, including prices, trading volume, market capitalization, and additional market statistics.

CoinDeskNewsTool to fetch the latest cryptocurrency news and transform raw articles into concise, readable summaries for users.

Separating these capabilities into reusable tools keeps the agent architecture clean while making future expansion straightforward.

Session Management: Conversation continuity is managed through ADK's InMemorySessionService. Each session preserves previous interactions, enabling the agent to interpret follow-up questions naturally without forcing users to repeat earlier requests.

Command-Line Experience: Although the application functions in the terminal, considerable attention was given to usability.

The CLI supports:

Interactive conversations

Continuous sessions

Clear prompts

Structured responses

Readable formatting

Helpful error messages

Development Workflow: The project uses PNPM for dependency management and Biome for linting and code formatting. Environment variables are securely managed via dotenv, allowing sensitive API credentials to remain separate from application code and simplify local development.

Integrating Multiple Real-Time APIs: CoinGecko and CoinDesk expose different response structures, update frequencies, and error conditions. Combining multiple APIs into a single AI workflow required careful handling of inconsistent response formats and ensuring the agent continued producing coherent answers even when one service became unavailable or rate-limited.

The Solution: I created dedicated abstraction layers for each API, allowing every tool to normalize external responses before passing structured information back to the agent. Comprehensive error handling ensures users receive meaningful feedback whenever data cannot be retrieved.

Result: The agent consistently delivers reliable, structured responses regardless of differences between external services.

Agent Choosing the Right Tool: Deciding which external tools to invoke for each request is an important aspect of agentic systems. Without carefully designed instructions, the language model could call unnecessary tools or generate responses without retrieving live information.

The Solution: I developed explicit system instructions that guide the agent's reasoning process and clearly define when each tool should be used.

The prompt was iteratively refined through extensive testing with different user queries to improve accuracy and reduce ambiguous responses.

Result: The agent reliably interprets user intent and invokes only the tools necessary to answer each request, improving both response quality and efficiency.

Maintaining Conversational Context: Many command-line AI applications treat every request as an isolated interaction, requiring users to repeat information during follow-up questions.

The Solution: Using ADK's session services, I implemented persistent conversation memory that preserves previous interactions throughout the terminal session.

Result: Users can naturally continue conversations, ask comparative questions, and reference earlier responses without restating context, creating a significantly more human-like interaction.

By integrating live market and news APIs, the agent delivers accurate information that traditional language models cannot provide independently.

Persistent session memory enables natural multi-turn conversations, creating a more intelligent and productive user experience.

The modular design makes it straightforward to introduce additional tools, APIs, or entirely new domains without redesigning the core agent architecture.