DEV Community: Rishabh Poddar

Is Siri AI? How Apple's Voice Assistant Really Works

Rishabh Poddar — Fri, 12 Jun 2026 04:09:15 +0000

Apple finally gave Siri the kind of upgrade people have been asking for, on and off, for years.

The new Siri AI is not just better speech recognition or a slightly smarter search box. Apple says it can understand what is on your screen, use personal context across messages and email, answer questions from the web, and take actions across apps. That moves Siri from a voice shortcut into something that looks a lot more like a real assistant.

That matters because Siri has always been one of the most visible consumer AI products on earth. When Apple changes Siri, it changes what a lot of people think an assistant should be able to do.

What changed in practice

At WWDC 2026, Apple introduced Siri AI as a rebuilt assistant powered by Apple Intelligence. The changes are pretty straightforward:

It can use personal context to find things in your messages, emails, photos, and other apps.
It has onscreen awareness, so it can answer questions about what you are currently looking at.
It can reach out to the web for up-to-date answers.
It can perform more systemwide actions across apps.
It now has a dedicated app for conversation history.
It includes expanded writing and editing tools.

Apple also leaned hard on privacy. Siri AI runs through Apple’s on-device and Private Cloud Compute architecture, which is the company’s way of saying it wants the assistant to stay useful without becoming a data leak.

That privacy angle is the interesting part. Most AI products get better by seeing more. Apple is trying to get more capable while seeing less.

Why this feels different

Old Siri was mostly a command layer. You asked for a timer, a reminder, a weather check, or a quick lookup. It was useful, but it stayed in a small lane.

Siri AI is trying to do something broader. If a friend texts you a restaurant recommendation, Siri should be able to find it. If you are looking at a message about a trip, it should help you act on it. If you are writing, it should help draft and edit in context.

That is a very different product shape.

Instead of just answering questions, the assistant can now handle multi-step tasks for you—like finding a flight confirmation in your email and adding it directly to your calendar without you having to copy and paste.

Why teams should care

While the Siri update is a consumer story, the lesson is bigger than Apple: as assistants get more powerful, the hard part stops being raw intelligence and becomes control. Who can the assistant see? What can it touch? When should it ask for approval? How do you keep secrets safe? How do you know what it did later?

That is the same reason TeamCopilot exists. Teams do not just need a smart assistant. They need a shared assistant they can trust, with permissions, approvals, workflows, and secret handling built in.

Once AI starts acting on your behalf, governance stops being a nice-to-have. If you want to see how to manage these permissions and security risks in your own team, these resources are a good place to start:

What to watch next

Siri AI's real test lies in daily use rather than keynote demos. Will people trust it to search across personal data? Will it stay fast enough to feel natural? Will it actually replace some of the tiny tasks people do every day? And will Apple keep the privacy promise intact as the assistant gets more capable?

Those questions matter because they will shape the rest of the market too. If Apple makes a privacy-first assistant feel genuinely useful, it will push every other assistant maker to explain how they handle memory, context, and action.

That pressure helps users, but it also helps set a better baseline for teams building internal agents. The future belongs to systems designed to act safely.

What this means for TeamCopilot

Siri AI is a good reminder that people do not want tools that only answer questions; they want tools that understand context, take action, and stay out of the way. But once an assistant can do more, it also needs more guardrails.

That is the gap TeamCopilot is built for. Shared skills, workflows, secret management, and approval controls let teams use AI agents without handing them unchecked access.

The real challenge isn't just making Siri smarter—it's building an assistant that users and teams can actually trust with their sensitive data.

FAQ

Is Siri AI now?

Yes. Apple has rebuilt Siri around Apple Intelligence, with personal context, onscreen awareness, web answers, and app actions.

What is new in Siri AI?

The big changes are contextual understanding, better conversation, a dedicated app, visual intelligence, and stronger writing tools.

Does Siri AI use personal data?

It can use personal context from apps like Messages, Mail, and Photos, but Apple says it does so through privacy-preserving architecture and on-device processing where possible.

Is Siri AI the same as ChatGPT or Gemini?

Not really. Siri AI is Apple’s own assistant layer, built into the operating system and designed around Apple hardware and privacy.

Why does Siri AI matter for businesses?

It shows that assistants are moving from simple chat into real action. That is the same shift businesses face when they adopt AI agents internally.

What is the biggest risk with more powerful AI assistants?

The biggest risk is overreach. If an assistant can see too much or act too freely, it can create privacy, security, and reliability problems.

How is TeamCopilot different from Siri AI?

Siri AI is a personal consumer assistant built into Apple devices. TeamCopilot is a shared team agent with skills, workflows, approvals, and secret controls for business use.

What is the main takeaway from Apple's Siri AI launch?

The main takeaway is that as assistants gain the power to act on our behalf, security and trust become just as important as capability.

How to Humanize AI Text Without Sounding Robotic

Rishabh Poddar — Fri, 12 Jun 2026 04:00:55 +0000

AI text usually sounds robotic for the same boring reasons. The sentences are too even. The transitions are too polished. The wording is technically fine, but it never quite sounds like a person.

So the fix is not just "make this sound human." You need a method that checks the draft, spots the AI tells, and rewrites it in passes until it reads naturally.

That is what the code below does.

What "humanized" actually means

Humanized text is not slangy or messy. It keeps the meaning intact, but it sounds like a real person wrote it once instead of a model polishing it three times.

In practice, that means:

sentence lengths vary
ideas do not all arrive in the same shape
the tone matches the audience
the wording is specific instead of generic
the draft does not lean on obvious AI crutches like repetitive transitions, fake nuance, or overclean symmetry

The code at a glance

The code takes a long input string and runs it through an iterative loop.

It splits the text into markdown chunks using top-level ## headings.
It runs a detector prompt on each chunk in parallel.
It collects the strongest AI-writing signals.
It rewrites the full original text using those findings.
It repeats until the text looks clean or it hits the max iteration count.

The code does not guess from vibes. It asks the model to point at concrete snippets, explain why they sound AI-like, and say what should change.

The full workflow code

This is the actual implementation.

import argparse
import json
import os
import sys
import re
import uuid
from typing import Any, Dict, List
from concurrent.futures import ThreadPoolExecutor, as_completed
from pathlib import Path

from google import genai
from google.genai import types
from pydantic import BaseModel, Field


MODEL = "gemini-3.5-flash"
INPUT_COST_PER_1M = 1.50
OUTPUT_COST_PER_1M = 9.00


def load_local_env_var(key_name: str) -> str:
    env_path = os.path.join(os.path.dirname(__file__), ".env")
    if not os.path.exists(env_path):
        raise KeyError(key_name)

    with open(env_path, "r", encoding="utf-8") as handle:
        for line in handle:
            line = line.strip()
            if not line or line.startswith("#") or "=" not in line:
                continue
            name, value = line.split("=", 1)
            if name.strip() == key_name:
                value = value.strip().strip('"').strip("'")
                if value:
                    return value

    raise KeyError(key_name)


if "GEMINI_API_KEY" not in os.environ:
    os.environ["GEMINI_API_KEY"] = load_local_env_var("GEMINI_API_KEY")

client = genai.Client(api_key=os.environ["GEMINI_API_KEY"])
OUTPUT_DIR = Path(__file__).resolve().parent / "data"


class Snippet(BaseModel):
    snippet: str = Field(description="Short excerpt from the text")
    reason: str = Field(description="Why the excerpt reads AI-like")
    fix: str = Field(description="What to change")


class DetectionResult(BaseModel):
    has_issues: bool = Field(description="Whether the text has AI-writing issues")
    snippets: List[Snippet] = Field(default_factory=list, max_length=5)


class RewriteResult(BaseModel):
    rewritten_text: str = Field(description="The full rewritten text")


def get_usage_count(usage: Any, names: List[str]) -> int:
    for name in names:
        value = getattr(usage, name, None)
        if value is not None:
            return int(value)
    return 0


def estimate_cost(prompt_tokens: int, output_tokens: int) -> float:
    return (prompt_tokens / 1_000_000.0) * INPUT_COST_PER_1M + (output_tokens / 1_000_000.0) * OUTPUT_COST_PER_1M


def trim_to_first_words(text: str, word_count: int = 6) -> str:
    words = text.split()
    if len(words) <= word_count:
        return text
    return " ".join(words[:word_count])


def split_into_chunks(text: str) -> List[str]:
    chunks: List[str] = []
    current: List[str] = []

    for line in text.splitlines():
        if re.match(r"^##\s+", line):
            if current:
                chunk = "\n".join(current).strip()
                if chunk:
                    chunks.append(chunk)
                current = []
            current.append(line)
        else:
            current.append(line)

    if current:
        chunk = "\n".join(current).strip()
        if chunk:
            chunks.append(chunk)

    return chunks or [text]


def call_gemini(prompt: str, *, response_model: type[BaseModel]) -> tuple[str, BaseModel, int, int, float]:
    response = client.models.generate_content(
        model=MODEL,
        contents=prompt,
        config=types.GenerateContentConfig(
            temperature=0.2,
            top_p=0.95,
            response_mime_type="application/json",
            response_schema=response_model,
        ),
    )

    raw_text = (response.text or "").strip()
    if not raw_text:
        raise RuntimeError("Gemini returned empty text")

    parsed = response_model.model_validate_json(raw_text)
    usage = getattr(response, "usage_metadata", None)
    prompt_tokens = get_usage_count(usage, ["prompt_token_count", "input_token_count"])
    output_tokens = get_usage_count(usage, ["candidates_token_count", "output_token_count", "response_token_count"])
    cost = estimate_cost(prompt_tokens, output_tokens)
    return raw_text, parsed, prompt_tokens, output_tokens, cost


def _detect_single_chunk(index: int, chunk_text: str) -> tuple[int, str, List[Dict[str, Any]], float, int, int, int]:
    detection_raw, detection, detection_prompt_tokens, detection_output_tokens, detection_cost = call_gemini(
        build_detection_prompt(chunk_text),
        response_model=DetectionResult,
    )

    chunk_snippets = [
        {**snippet.model_dump(), "snippet": trim_to_first_words(snippet.snippet)}
        for snippet in detection.snippets
    ]
    return index, detection_raw, chunk_snippets, detection_cost, detection_prompt_tokens, detection_output_tokens, len(chunk_snippets)


def detect_issues_in_chunks(chunks: List[str]) -> tuple[List[Dict[str, Any]], float, int]:
    return detect_issues_in_chunks_parallel(chunks, verbose=True)


def detect_issues_in_chunks_silent(chunks: List[str]) -> tuple[List[Dict[str, Any]], float, int]:
    return detect_issues_in_chunks_parallel(chunks, verbose=False)


def detect_issues_in_chunks_parallel(chunks: List[str], verbose: bool) -> tuple[List[Dict[str, Any]], float, int]:
    all_snippets: List[Dict[str, Any]] = []
    seen = set()
    total_cost = 0.0
    total_chunks = 0

    max_workers = max(1, min(8, len(chunks)))
    with ThreadPoolExecutor(max_workers=max_workers) as executor:
        futures = [executor.submit(_detect_single_chunk, index, chunk_text) for index, chunk_text in enumerate(chunks, start=1)]
        chunk_results = [future.result() for future in as_completed(futures)]

    for index, detection_raw, chunk_snippets, detection_cost, detection_prompt_tokens, detection_output_tokens, snippet_count in sorted(chunk_results, key=lambda row: row[0]):
        if verbose:
            print(f"\n=== Chunk {index} Detection Result ===")
            print(detection_raw)
            print(f"Chunk {index} detection cost: ${detection_cost:.6f} ({detection_prompt_tokens} input tokens, {detection_output_tokens} output tokens)")
            if chunk_snippets:
                print(json.dumps(chunk_snippets, ensure_ascii=False, indent=2))

        for snippet in chunk_snippets:
            key = (snippet.get("snippet"), snippet.get("reason"), snippet.get("fix"))
            if key in seen:
                continue
            seen.add(key)
            all_snippets.append(snippet)

        total_cost += detection_cost
        total_chunks += 1

    return all_snippets, total_cost, total_chunks


def process_text(input_text: str, max_iterations: int = 10, rewrite_style: str = "", verbose: bool = True) -> dict:
    current_text = input_text
    total_cost = 0.0
    iteration = 0
    first_iteration_issues: List[Dict[str, Any]] = []
    forced_rewrite_done = False

    for iteration in range(1, max_iterations + 1):
        chunks = split_into_chunks(current_text)
        if verbose:
            print(f"Iteration {iteration}: {len(chunks)} chunk(s)")
        all_snippets, detection_cost, _ = detect_issues_in_chunks_parallel(chunks, verbose=verbose)

        if iteration == 1:
            first_iteration_issues = all_snippets

        has_issues = bool(all_snippets)
        if verbose:
            print(f"Iteration {iteration}: {len(all_snippets)} issue(s) found")

        iteration_cost = detection_cost

        should_force_rewrite = bool(rewrite_style.strip()) and not forced_rewrite_done
        should_rewrite = has_issues or should_force_rewrite

        if not should_rewrite:
            total_cost += iteration_cost
            if verbose:
                print(f"Iteration {iteration} total cost: ${iteration_cost:.6f}")
            break

        rewrite_raw, rewrite_output, rewrite_prompt_tokens, rewrite_output_tokens, rewrite_cost = call_gemini(
            build_rewrite_prompt(input_text, all_snippets, rewrite_style=rewrite_style),
            response_model=RewriteResult,
        )
        current_text = rewrite_output.rewritten_text
        forced_rewrite_done = True
        iteration_cost += rewrite_cost
        total_cost += iteration_cost
        if verbose:
            print(f"Iteration {iteration}: rewrite applied")

    return {
        "final_output": current_text,
        "total_cost": round(total_cost, 6),
        "iterations": iteration,
        "model": MODEL,
        "first_iteration_issues": first_iteration_issues,
    }




def build_detection_prompt(text: str) -> str:
    return f"""Audit the text for AI-writing tells.

Focus on concrete signals, not vague vibes:

- Em dash overuse: repeated `—`, lists built around em dashes, em dashes used as a default stylistic crutch, or multiple paragraphs that lean on em dashes for rhythm.
- Contrast formulas: "it's X, not Y", "not only X, but also Y", "this isn't just X, it's Y", "the real answer isn't X".
- Meta-openers: "what usually gets skipped here is...", "what people often miss is...", "the part people forget is...", "what matters most is...", "what gets overlooked is...", "this is exactly the sort of...", "this is basically why...", "this is the kind of...".
- One-line paragraph patterns: lots of short single-sentence paragraphs in a row.
- Paragraph stubs: a paragraph that starts with a short setup sentence and then immediately follows with a tiny paragraph of 2-5 words, or a paragraph that is itself only 2-5 words long.
- Outline scaffolding: numbered headings or label-only sections like `### 1. Security`, `### 2. Reliability`, or repeated short section labels that read like an outline instead of prose.
- Choppy fragmentation: paragraphs with 2-4 very short sentences that all carry pieces of one idea and could naturally become a single sentence. Prioritize this signal even if the paragraph also contains a meta-opener.
- Template transitions: "that works, until it doesn't", "in today's world", "at the end of the day", "ultimately", "overall".
- Symmetry: repeated sentence openings, repeated clause shapes, evenly balanced comparisons, or neat bullet/list structures that feel engineered.
- Generic polish: buzzwords, hedging, fake nuance, or conclusion sentences that sound like a marketing page.
- Sycophancy: excessive praise toward the user, flattering language, "you nailed it", "great question", "this is exactly the right approach", or over-agreeable validation that adds no substance.
- Over-polished cadence: text that is technically clean but too symmetrical, too tidy, too templated, or too optimized for scannability.
- Repetitive feature-list formatting: bold labels, em-dash lists, or repeated "X — Y" constructions that create a slide-deck feel.

Return JSON only in this exact shape:
{{
  "has_issues": true|false,
  "snippets": [
    {{"snippet": "short identifying excerpt", "reason": "short reason", "fix": "short fix"}}
  ]
}}

Rules:
- Return at most 5 snippets.
- Snippets must be short. Use only the first few words needed to identify the line.
- Keep `reason` and `fix` concise.
- If the text is natural, return `has_issues: false` and `snippets: []`.
- Prefer the strongest signals only.
- If a paragraph splits one idea across multiple short sentences, flag that fragmentation even if each sentence is individually understandable.
- If a paragraph is just 2-5 words, always flag it.

Text:
{text}"""


def build_rewrite_prompt(original_text: str, issues: List[Dict[str, Any]], rewrite_style: str = "") -> str:
    issues_json = json.dumps(issues, ensure_ascii=False, indent=2)
    rewrite_style_block = f"\nAdditional rewrite style guidance:\n{rewrite_style}\n" if rewrite_style.strip() else ""
    return f"""Rewrite the text so it sounds human and natural while preserving meaning, facts, proper nouns, and formatting that still helps the content.

Use these rules:
- Direct over ornate.
- Specific over vague.
- Mix short and long sentences.
- Prefer simple verbs and concrete nouns.
- Delete fluff instead of disguising it.
- Avoid robotic symmetry, generic closings, and over-polished transitions.
- Keep the level of formality appropriate to the original content.

Address these flagged issues:
{issues_json}
{rewrite_style_block}

Return valid JSON only with this schema:
{{
  "rewritten_text": "the full rewritten text"
}}

Original text:
{original_text}"""


def main() -> int:
    parser = argparse.ArgumentParser(description="Humanise text with iterative Gemini rewrites.")
    parser.add_argument("--input_text", required=True, help="The text to humanise")
    parser.add_argument("--max_iterations", type=int, default=10, help="Maximum rewrite/detection loops to run")
    parser.add_argument("--rewrite_style", default="", help="Additional style guidance for the rewrite prompt")
    args = parser.parse_args()

    summary = process_text(args.input_text, max_iterations=args.max_iterations, rewrite_style=args.rewrite_style, verbose=True)
    OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
    output_path = OUTPUT_DIR / f"final_rewrite_{uuid.uuid4().hex}.json"
    output_path.write_text(summary["final_output"], encoding="utf-8")
    console_summary = {
        "output_path": str(output_path),
        "iterations": summary["iterations"],
        "total_cost": summary["total_cost"],
        "model": summary["model"],
    }
    print(json.dumps(console_summary, ensure_ascii=False, indent=2))
    return 0


if __name__ == "__main__":
    try:
        raise SystemExit(main())
    except Exception as exc:
        print(f"Error: {exc}", file=sys.stderr)
        raise SystemExit(1)

How the code works

The code looks long, but the logic is simple.

1. It loads Gemini securely

The workflow expects GEMINI_API_KEY to be present in the runtime environment. If it is not there, it tries to read a local .env file inside the workflow folder.

That matters because TeamCopilot workflows are meant to run with secrets injected safely, not pasted into prompts or hardcoded into source.

2. It uses structured outputs

Both the detector and the rewrite step use Pydantic models.

That means the model cannot just return a messy blob of text. It has to return valid JSON in the shape the workflow expects:

DetectionResult gives has_issues plus up to five flagged snippets
RewriteResult gives the full rewritten text

It makes the workflow predictable, which is what you want if other people are going to reuse the output.

3. It scans in chunks

The workflow splits the input on top-level ## headings so it can inspect each section separately.

That helps because long blog drafts usually mix clean sections with sections that still sound synthetic. Chunking keeps the detector focused instead of asking it to judge a giant wall of text all at once.

4. It runs detection in parallel

Each chunk is checked in parallel with a thread pool, which keeps the process moving on longer drafts.

The detector is not just looking for one thing. It flags patterns like:

em dash overuse
contrast formulas like "it's X, not Y"
meta-openers like "what people often miss is"
overclean section scaffolding
repetitive sentence shapes
generic closing lines

5. It rewrites only when needed

If the detector finds issues, the workflow rewrites the full original text using those findings.

If it finds nothing, it stops early.

There is one exception. If you pass a non-empty rewrite_style, the workflow forces at least one rewrite pass even if the detector says the text is clean. That is useful when you want a specific voice or house style layered in.

6. It writes the final result to disk

When the loop is done, the workflow writes the final rewrite to a file in data/ and prints a small JSON summary to stdout.

That summary includes:

output_path
iterations
total_cost
model

How to use it

In TeamCopilot, the workflow takes these inputs:

input_text: the text you want humanized
max_iterations: how many detect and rewrite loops to run, default 10
rewrite_style: optional style guidance that forces at least one rewrite pass

A simple run looks like this.

{
  "input_text": "AI tools are changing how teams work. We need to use these tools to make our workflows faster and more efficient, which ultimately helps us deliver better results.",
  "max_iterations": 10,
  "rewrite_style": "Keep it warm, practical, and a little conversational."
}

The workflow might return a summary like this:

{
  "output_path": "data/final_rewrite_7a1d8f2c3d9e4b31b4d2d1ef9c1c5e5f.json",
  "iterations": 2,
  "total_cost": 0.008412,
  "model": "gemini-3.5-flash"
}

The file at output_path contains the final rewritten text.

Example inputs and outputs

Here are simple before and after examples.

Example 1

Input

You are exactly right! The code indeed has a bug.

Output

The code has a bug.

Here is another example with a style guide added.

Example 2

Input

That's exactly the right approach. The way to solve this problem is to use an iterative loop with a detector and a rewrite step.

`rewrite_style`

Write it as a friendly reddit comment in first person style.

Output

I've had the best luck tackling this with an iterative loop. You basically just need a detector and a rewrite step to get it done.

Why this is better than a single rewrite prompt

A single prompt can help, but it usually stops at surface cleanup.

This workflow is stronger because it separates the problem into two jobs:

find the AI tells
rewrite around those tells

That is how editors work too. First they spot the bad habits. Then they fix them. Then they read it again.

FAQ

What does the code actually do?

It audits text for AI-writing patterns, flags the strongest issues, rewrites the full draft, and repeats until the text reads naturally or the maximum iteration count is reached.

Does it change the meaning of the text?

It is designed not to. The rewrite prompt tells the model to preserve meaning, facts, proper nouns, and useful formatting.

Why does it split text into chunks?

Long drafts are easier to inspect section by section. Chunking also lets the detector focus on one section at a time instead of making one big judgment on the entire post.

Why use structured output instead of plain text?

Structured output makes the workflow reliable. The detector must return a clear JSON object with snippets, reasons, and fixes. The rewrite step must return the final text in a known shape.

What if the detector finds nothing?

The workflow stops early and returns the current text. That saves time and cost.

What does `rewrite_style` do?

It adds extra guidance for tone or voice. If you pass a non-empty value, the workflow runs at least one rewrite pass even when the detector does not find obvious issues.

Can I use this on blog posts only?

No. It can be used on blog posts, docs, support text, internal notes, landing pages, and other long-form writing.

What kind of AI tells does the code look for?

It looks for things like repetitive transitions, overly symmetrical sentence shapes, one-line paragraph patterns, vague buzzwords, fake nuance, em dash overuse, and contrast formulas that read like template writing.

What is the best input format?

Use a full draft with headings and normal paragraph flow. The code is built to work on substantial text, not just a sentence or two.

How many iterations should I use?

The default is 10. In practice, most drafts should not need that many. If the text is already decent, the code stops early.

Is the output deterministic?

No. It uses a model, so two runs can produce slightly different rewrites. The structure of the code stays the same, though, which is what matters for repeatability.

Does this replace human editing?

No. It gets the draft much closer, but the best results still come from a human pass at the end.

How is this different from a generic AI humanizer?

Most generic tools just rewrite surface phrasing. This code does the more useful thing: it detects the patterns first, rewrites in passes, and gives you a predictable process you can reuse.

How to Visually Debug Multi AI-Agent Flows

Rishabh Poddar — Wed, 18 Jun 2025 14:30:00 +0000

Multi AI-Agent systems represent a significant advancement in software development, characterized by two fundamental aspects:

Collaborative Intelligence: Multiple AI agents working together to achieve shared objectives, each contributing their specialized capabilities.
Dynamic Decision Making: Systems that employ AI-driven tool calling to determine execution paths based on real-time context, rather than following predetermined logic flows.

The dynamic nature of these systems presents a unique challenge: understanding the flow of logic becomes increasingly complex as the system scales. A single query might trigger no tool calls, while another could initiate a cascade of nested interactions where AI agents themselves trigger additional tool calls. This complexity makes system behavior difficult to track and debug.

To address this challenge, I'm introducing AgentGraph, an open-source library that seamlessly integrates with Python or Node.js backends. This tool captures and visualizes LLM interactions and tool calls in real-time, presenting them as an interactive graph that provides clear visibility into system behavior.

Visualizing Agent Interactions

Let's examine a practical example: a database query agent with access to two tools:

SQLAgent: Converts natural language queries into SQL
DatabaseAgent: Executes SQL queries and returns results

Here's how the agent graph visualizes different types of interactions:

Query 1: "Hi there!"

A simple greeting that doesn't require database access results in no tool calls:

Query 2: "How many users do I have?"

This query triggers a sequence of tool calls:

SQLAgent converts the query to SQL
DatabaseAgent executes the query

The main agent's graph shows:

The second bubble contains the user input (also indicating that the LLM used tools), followed by the final response bubble. Clicking the second bubble reveals the tool calls:

The LLM first calls SQLAgent, then DatabaseAgent. Clicking on the SQLAgent row shows its subgraph:

The subgraph displays the tool input (orange box), output (green box), and complete LLM chat history. While this example shows a simple tool, the visualization scales to handle complex nested tool calls. The DatabaseAgent's subgraph shows:

Since this tool doesn't use an LLM, it simply displays the input and output.

Integration Guide

Let's walk through implementing AgentGraph in a Node.js backend. You can find the complete example code here. While we'll focus on Node.js, the implementation is similar for Python backends.

To get started, install the AgentGraph package:

npm install @trythisapp/agentgraph

Setting Up the Main Agent

The core of the integration involves wrapping your LLM calls with AgentGraph's callLLMWithToolHandling function. Here's how to set up the main agent:

import { callLLMWithToolHandling, clearSessionId } from "@trythisapp/agentgraph";
import { v4 as uuidv4 } from 'uuid';

async function mainAgent(userInput: string, sessionId: string) {
    let input: OpenAI.Responses.ResponseInput = [{
        role: "system",
        content: `You are a helpful assistant for querying a database...`
    }, {
        role: "user",
        content: userInput
    }];

    try {
        let response = await callLLMWithToolHandling(
            "mainAgent",           // Agent name for visualization
            sessionId,             // Unique session identifier
            undefined,             // Tool ID (undefined for main agent)
            async (inp) => {       // LLM call function
                return await openaiClient.responses.create({
                    model: "gpt-4.1",
                    input: inp,
                    tools: [/* tool definitions */],
                });
            },
            input,                 // Input messages
            [/* tool implementations */]
        );

        console.log(response.output_text);
    } finally {
        clearSessionId(sessionId);  // Clean up session data
    }
}

Session Management

Each interaction requires a unique session ID to track the conversation flow:

let sessionId = uuidv4();
console.log(`Session ID: ${sessionId}. File is saved in ./agentgraph_output/${sessionId}.json`);

The session ID serves two purposes:

Visualization: Groups related interactions in the same graph
File Output: Creates a JSON file with the complete interaction trace

Always call clearSessionId(sessionId) when the session ends to clean up memory.

Defining Tools

Tools are defined using OpenAI's function calling format within the LLM call:

tools: [{
    type: "function",
    strict: true,
    name: "SQLAgent",
    description: "Use this tool when you need to convert the natural language query into a SQL query",
    parameters: {
        type: "object",
        properties: {
            query: {
                type: "string",
                description: "The natural language query to convert into a SQL query"
            }
        },
        required: ["query"],
        additionalProperties: false
    }
}, {
    type: "function",
    strict: true,
    name: "databaseAgent",
    description: "Use this tool when you need to execute the SQL query and return the results",
    parameters: {
        type: "object",
        properties: {
            query: {
                type: "string",
                description: "The SQL query to execute"
            }
        },
        required: ["query"],
        additionalProperties: false
    }
}]

Implementing Tool Handlers

The final parameter of callLLMWithToolHandling is an array of tool implementations:

[{
    toolName: "SQLAgent",
    impl: async ({ query }: { query: string }, toolId: string) => {
        return runSQLAgent(sessionId, toolId, query);
    }
}, {
    toolName: "databaseAgent", 
    impl: async ({ query }: { query: string }) => {
        return runDatabaseAgent(query);
    }
}]

Each tool implementation receives:

Parameters: The arguments passed by the LLM (destructured from the first parameter)
Tool ID: A unique identifier for this specific tool call (used for nested visualization)

Creating Nested Agents

For tools that use LLMs internally (like SQLAgent), you create nested agents by calling callLLMWithToolHandling again:

async function runSQLAgent(sessionId: string, toolId: string, query: string): Promise<string> {
    let input: OpenAI.Responses.ResponseInput = [{
        role: "system",
        content: `You are an expert SQLite SQL query generator...`
    }, {
        role: "user",
        content: query
    }];

    let response = await callLLMWithToolHandling(
        "SQLAgent",        // Nested agent name
        sessionId,         // Same session ID
        toolId,            // Tool ID from parent call
        async (inp) => {
            return await openaiClient.responses.create({
                model: "gpt-4.1",
                input: inp,
                text: {
                    format: {
                        type: "json_schema",
                        name: "sqlQuery",
                        schema: {/* JSON schema */}
                    }
                }
            });
        },
        input,
        []                 // No tools for this agent
    );

    return response.output_text;
}

Notice how the nested agent:

Uses the same sessionId to maintain session continuity
Receives the toolId from the parent to establish the parent-child relationship
Can have its own tools or none at all

Simple Tool Implementation

For tools that don't use LLMs (like databaseAgent), the implementation is straightforward:

async function runDatabaseAgent(query: string): Promise<string> {
    return queryDatabase(query);  // Direct function call
}

Viewing the Results

After running your agent, AgentGraph seamlessly handles the complete interaction flow:

Automatic Tool Orchestration: When the LLM decides to invoke a tool, callLLMWithToolHandling automatically executes the corresponding tool implementation and feeds the result back to the LLM for further processing.
Complete Trace Capture: Every interaction, tool call, and response is captured and saved to ./agentgraph_output/${sessionId}.json, creating a comprehensive execution trace.
Interactive Visualization: The generated JSON file can be visualized using the AgentGraph visualizer, which renders your agent interactions as an interactive graph.

The visualization provides:

Chat Flow: LLM interactions as conversation bubbles
Tool Calls: Expandable sections showing tool inputs and outputs
Nested Agents: Subgraphs for tools that use LLMs internally
Execution Flow: Clear visual representation of the decision-making process

This integration approach provides complete visibility into your multi-agent system without requiring significant changes to your existing code structure.

Take away

As AI agent systems become increasingly sophisticated, the ability to understand and debug their behavior becomes crucial for reliable deployment. AgentGraph addresses this challenge by providing real-time visualization of multi-agent interactions, making complex decision flows transparent and debuggable.

Key benefits of using AgentGraph include:

Zero-friction Integration: Minimal code changes required to instrument your existing agent systems
Complete Visibility: Track every LLM interaction, tool call, and nested agent execution
Interactive Debugging: Visual graph interface that lets you drill down into specific interactions
Multi-language Support: Works seamlessly with both Python and Node.js backends
Session Management: Automatic trace capture and file generation for analysis

Whether you're building simple tool-calling agents or complex multi-agent orchestration systems, AgentGraph provides the observability you need to understand, debug, and optimize your AI workflows.

Check out the AgentGraph repository and give it a ⭐ if you find it useful! Your support helps me continue developing tools that make AI development more transparent and accessible.

DEV Community: Rishabh Poddar

Is Siri AI? How Apple's Voice Assistant Really Works

What changed in practice

Why this feels different

Why teams should care

What to watch next

What this means for TeamCopilot

FAQ

Is Siri AI now?

What is new in Siri AI?

Does Siri AI use personal data?

Is Siri AI the same as ChatGPT or Gemini?

Why does Siri AI matter for businesses?

What is the biggest risk with more powerful AI assistants?

How is TeamCopilot different from Siri AI?

What is the main takeaway from Apple's Siri AI launch?

How to Humanize AI Text Without Sounding Robotic

What "humanized" actually means

The code at a glance

The full workflow code

How the code works

1. It loads Gemini securely

2. It uses structured outputs

3. It scans in chunks

4. It runs detection in parallel

5. It rewrites only when needed

6. It writes the final result to disk

How to use it

Example inputs and outputs

Example 1

Input

Output

Example 2

Input

rewrite_style

Output

Why this is better than a single rewrite prompt

FAQ

What does the code actually do?

Does it change the meaning of the text?

Why does it split text into chunks?

Why use structured output instead of plain text?

What if the detector finds nothing?

What does rewrite_style do?

Can I use this on blog posts only?

What kind of AI tells does the code look for?

What is the best input format?

How many iterations should I use?

Is the output deterministic?

Does this replace human editing?

How is this different from a generic AI humanizer?

How to Visually Debug Multi AI-Agent Flows

Visualizing Agent Interactions

Query 1: "Hi there!"

Query 2: "How many users do I have?"

Integration Guide

Setting Up the Main Agent

Session Management

Defining Tools

Implementing Tool Handlers

Creating Nested Agents

Simple Tool Implementation

Viewing the Results

Take away

`rewrite_style`

What does `rewrite_style` do?