Building Your First Cognitive Agent: A 10-Minute Guide to Problem-Solving with AI

Large Language Models (LLMs) have changed the way we interact with software. We can generate text, summarize articles, and even write code with a simple prompt. But what happens when the task is more complex than a single request-response? What if you need an AI that doesn't just answer a question, but actively achieves a goal?

This is where the next evolution of AI comes in: Agentic AI. It's the shift from conversational chatbots to autonomous problem-solvers. Instead of just generating text, these agents can reason, create a plan, use tools, and execute multi-step tasks to reach a desired outcome.

Welcome to thinking.do, the cognitive automation engine designed to make this power accessible to every developer. In this guide, we'll show you how to go beyond basic prompts and build your first cognitive agent in less than 10 minutes.

The Paradigm Shift: From Prompts to Goals

The fundamental difference between a standard LLM API and an agentic platform like thinking.do lies in the objective.

• A Prompt: You give an LLM a specific instruction, and it gives you back a text-based response. The process is stateless and linear.
• A Goal: You give an agent a high-level objective. The agent then autonomously breaks that goal down into steps, selects the right tools for each step, executes them, and synthesizes the results to accomplish the mission.

This is the core of Cognitive Automation. It's not just about language; it's about task completion. The LLM acts as the "brain" or reasoning core, but the platform provides the framework for planning, memory, and tool usage that enables true problem-solving.

Let's Build: A Market Trend Analysis Agent

Theory is great, but let's get practical. We're going to build an AI agent that can perform real-time market research—a task that would normally take a human analyst hours of work.

Our Goal: Analyze recent tech news, identify the top 3 emerging AI trends, and write a one-paragraph summary for each.

Step 1: Setting Up Your Environment

First, you'll need the thinking.do SDK. Assuming you have Node.js installed, simply run:

npm install @do/sdk

Step 2: Writing the Code

Now, create a new TypeScript file (e.g., market-analyst.ts) and paste in the following code. It's remarkably simple.

import { Agent } from '@do/sdk';

// Initialize your connection to the cognitive engine
const thinker = new Agent('thinking.do');

async function analyzeMarketTrends() {
  console.log('Agent is starting to think...');

  const result = await thinker.run({
    goal: 'Analyze recent tech news, identify the top 3 emerging AI trends, and write a one-paragraph summary for each.',
    tools: ['web.search', 'document.summarize']
  });

  console.log('Analysis Complete! Here are the results:');
  console.log(JSON.stringify(result.output, null, 2));
  
  // Expected Output Structure:
  // {
  //   "trends": [
  //     {
  //       "trend": "Large-Scale Multimodal Models",
  //       "summary": "Leading AI labs are developing models..."
  //     },
  //     {
  //       "trend": "On-Device AI and Edge Computing",
  //       "summary": "There is a significant push to run powerful..."
  //     },
  //     {
  //       "trend": "Generative AI in Enterprise",
  //       "summary": "Businesses are increasingly adopting..."
  //     }
  //   ]
  // }
}

analyzeMarketTrends();

Step 3: Run Your Agent

Execute the file from your terminal:

npx ts-node market-analyst.ts

That's it! In a few moments, your agent will return a structured JSON object containing a clean, concise, and up-to-date analysis of AI market trends.

What Just Happened? The Agent's Thought Process

While the code looks simple, a complex cognitive workflow just took place. The thinking.do engine didn't just "answer" your goal—it executed a plan.

1. Decomposition: The agent received the high-level goal and broke it down. "First, I need to find recent news about AI. Then, I need to read several articles to find common themes. After that, I will identify the top three and summarize each one."
2. Tool Selection: The agent saw that to get "recent tech news," it needed to access the live internet. It selected the web.search tool. To process the content of the articles it found, it chose the document.summarize tool.
3. Execution: It ran multiple web searches, fetched the most relevant articles, and then fed their content into the summarization tool. It iterated through this process, gathering and refining its understanding.
4. Synthesis: Finally, it took all its intermediate findings and synthesized them into the final, structured JSON format you requested.

The best part? This entire reasoning process isn't a "black box." With thinking.do, you get full transparency into the agent's plan and every step it took, allowing for complete observability and control.

Beyond Research: The Future is Agentic

This simple market analyst is just the beginning. Because thinking.do is an extensible Problem Solving API, you can build agents for virtually any complex digital task:

• Automated Reporting: An agent that connects to your internal database, pulls raw sales data, performs an analysis, and drafts a weekly summary email to the leadership team.
• Complex Trip Planning: An agent that finds flights, checks hotel availability, looks up local events, and builds a complete travel itinerary based on a user's preferences and budget.
• Business-as-Code: An agent that can triage customer support tickets by understanding the user's intent, querying your internal knowledge base with its own tools, and either providing an answer or routing it to the correct human expert.

By allowing you to securely connect your own private data, internal APIs, and custom functions, you empower agents to operate with the full context of your business.

Ready to go beyond prompts and start achieving goals?

Visit thinking.do to get your API key and build your first cognitive agent today!