Forem: Marton Kodok

Cross-Agent Synergy: How I keep Gemini CLI in sync with other AI tools?

Marton Kodok — Wed, 11 Mar 2026 15:57:38 +0000

In today's fast-moving development world, different teams often rely on distinct solutions like Gemini CLI, VS Code Copilot and Cursor, meaning "the AI" is rarely just one tool.

Personally, I prefer Gemini CLI over other tools—I identify more with its prompting style and the high quality of code it produces—though my human colleagues often switch between these various platforms for surgical, programmatic power.

But each tool has its "own way" of defining and use expertise. In these, we found .agents/skills folder the universal way available across all tool, containing specialized instructions (SKILL.md). This gives me a unified, markdown-driven logic that works everywhere, keeping me synced while staying ahead of the curve — I am the one leading top-notch solutions to the team.

While Gemini CLI is powerful enough to discover and use these skill files automatically during its reasoning process. A feature I like in Gemini CLI, we could rely on command files in .gemini/command folder available as /slash prompts.

I prefer having them explicitly available as Slash Commands. This allows for a more "surgical" approach, where I can invoke a specific expert skill instantly without relying on the model's general discovery.

Here's how I automated the linking of these skills into my native Gemini CLI commands.

The Transformation

Before:

├── .agents/
│   └── skills/
│       └── agent-generate-agent-md/
│           └── SKILL.md
└── .gemini/
    └── settings.json

After:

├── .agents/
│   └── skills/
│       └── agent-generate-agent-md/
│           └── SKILL.md
└── .gemini/
    ├── commands/
    │   └── agentGenerateAgentMd.toml
    └── settings.json

The Shortcut: `/agentSyncSkills`

One feature I really love in the Gemini CLI is the ability to run commands with slash /myCommand. It's the fastest way to call a specialized skill with custom parameters. It turns a static prompt into a dynamic, reusable tool.

However, when my human collegues adds a new skill to the .agents/skills folder, I'm not automatically aware of it as a Gemini command.

So, I built a command for myself: /agentSyncSkills.

To automate this bridge, I use a custom command definition. This command tells me how to scan the project for external skills and transform them into native Gemini CLI commands.

description="sync skills from .agents/skills folder"
prompt = '''
The goal of this prompt is to create custom commands for the Gemini CLI 
from a universally defined skills folder.

 You need to search the existing folders from `.agents/skills/`.
Each folder name describes an agent. Inside each folder is a `SKILL.md` file.

Your job is to create a `.gemini/commands/agent[Name].toml` file for each new skill you find.
Rules for the generated files:

1. Naming convention: each file starts with the \"agent\" prefix, followed by PascalCase (e.g., `agentSyncSkills.toml`).
2. The commands must reference the skills file rather than reusing the prompt contents.
3. You must use the EXACT path to the `SKILL.md` file in the `@` include syntax.

Below is the template for the files you need to generate. 

CRITICAL INSTRUCTION: In the template below, I have used `[AT]` to represent the \"at\" symbol. 
When you generate the final TOML files in the bash script, you MUST replace `[AT]` with the actual `@` character so the file injection works.

---
description="you put here a brief description of the agent"
prompt = """
Use the following files instructions to resolve the user's ask:
[AT]{.agents/skills/[InsertFolderNameHere]/SKILL.md}
"""
---

No need to create a global search for SKILL.md files to ensure no other skills were missed.
Output the list of commands you just created. Do not create files for skills that already have a .toml file.

And inform me to run /commands reload
'''

Automating the Sync

My /agentSyncSkills workflow follows a simple but powerful logic:

Discovery: it lists the contents of .agents/skills/ and compare it with .gemini/commands/.
Extraction: For any missing command, it reads the corresponding SKILL.md. I extract its description and instructions.
Generation: creates a new .toml file to .gemini/commands/, mapping the skill's logic into our custom command format.

Now, whenever a new skill is added to the project, I can \"digest\" it and make it available as a /agentMyCommand shortcut in seconds.

NOTE: As you see I use references in my Gemini CLI command definitions @{ .agents/skills/[InsertFolderNameHere]/SKILL.md } which gives me the leverage as a symlink, so whenever the skill is modified my command does not need to be updated.

The Missing Link: Programmatic Reloading

There's one final hurdle in this automation. After I generate these new command files, I need to manually run /commands reload.

Can an agent instruct the CLI to reload itself?

Currently, the answer is no. Slash commands like /commands reload are user-level meta-controls.

My `settings.json`

{
  "ui": {
    "hideBanner": true
  },
  "context": {
    "fileName": ["AGENTS.md"]
  }
}

Feel free to reach out to me on Linkedin or read my previous posts on Dev.to

We at REEA.net are open to providing specialized knowledge, software development to your Google Cloud needs. Get in contact with Marton to kickstart discussions.

Revolutionizing Trademark creation with AI-Powered Class Suggestions

Marton Kodok — Sat, 28 Feb 2026 20:01:25 +0000

By fine-tuning a custom LLM on our extensive database of millions of USPTO trademark records, we have developed what we believe is the most accurate and high-performance trademark class suggester in the industry.

One of the most daunting aspects of trademark registration is identifying the correct Nice Classification. Selecting the wrong class can lead to application delays, office actions, or even total rejection. To solve this, we’ve launched the /v1/suggestClass endpoint—an AI-driven engine designed to bridge the gap between business descriptions and USPTO-recognized classifications.

How It Works

The /v1/suggestClass endpoint leverages advanced Natural Language Processing (NLP) to analyze your business context. Unlike simple keyword matching, our engine understands the intent and nature of your goods or services.

Flexible Input Options

The engine is designed to be flexible. To get started, you only need to provide one of the following parameters, though providing more context yields higher precision:

description (Recommended): A plain-text narrative of your business activities. This is the most powerful input for the AI.
keyword: A specific brand name or industry term.
owner: The name of an entity, allowing the AI to analyze historical filings for similar contexts.
serial_number: A USPTO serial number to find similar or related classifications.

Practical Examples

Example 1: Mapping a Brand Narrative

When a developer provides a descriptive "vibe" of a business, the AI can extract both the physical goods and the service-based nature of the venture.

Request Context:

"Step into a sanctuary where rich, artisanal teas from around the world meet a warm, cozy ambiance..."

AI Recommendations:

{
    "recommendations": [
        {
            "class_code": "30",
            "description": "Teas and infusions are specifically listed in Class 30.",
            "confidence": "High",
            "official_description": "Coffee, tea, cocoa... yeast, baking-powder; salt, seasonings, spices..."
        },
        {
            "class_code": "43",
            "description": "The description mentions a 'sanctuary' with a 'cozy ambiance', strongly suggesting a cafe or restaurant service.",
            "confidence": "High",
            "official_description": "Services for providing food and drink; temporary accommodation."
        }
    ]
}

Example 2: Keyword-Based Inference

Even with a single keyword like "TrademarkSearch", the engine can distinguish between the service itself and the software behind it.

Request Context:

keyword: "TrademarkSearch"

AI Recommendations:

{
    "recommendations": [
        {
            "class_code": "35",
            "description": "Services related to business management, advertising, and commercial information, which includes trademark search services.",
            "confidence": "High"
        },
        {
            "class_code": "45",
            "description": "Legal services, including intellectual property services and trademark registration.",
            "confidence": "Medium"
        }
    ]
}

Integration & Pricing

The /v1/suggestClass endpoint is a premium utility. Because it utilizes significant computational resources for real-time AI inference, each call consumes 10x credits compared to standard search endpoints.

Developer Tips for Success

Detail is Key: While a keyword works, a 2-3 sentence business description provides the highest "High" confidence matches.
Use the Confidence Score: Use the confidence field to programmatically decide whether to automatically select a class or flag it for human review.
Combine Parameters: Passing both a keyword and a description helps the AI understand the branding context alongside the service model.

By integrating /v1/suggestClass into your filing workflow, you can reduce user friction, minimize classification errors, and provide a more intuitive experience for non-expert filers.

What are the best trademark APIs for developers?

Marton Kodok — Fri, 06 Feb 2026 22:42:44 +0000

When building intellectual property applications, brand protection tools, or business intelligence platforms, access to reliable trademark data is crucial. While the USPTO provides the raw data, accessing it programmatically can be a significant hurdle.

Here are the top 3 trademark APIs for developers, ranked by reliability, ease of use, and feature set.

1. USPTO API from RapidAPI

The Gold Standard for Developers

The USPTO Trademark API on RapidAPI sits firmly at the number one spot. It is designed specifically with the developer experience in mind, solving the major pain points associated with government data.

Key Benefits:

📅 Updated Daily: One of the most critical factors in trademark law is timeliness. This API ensures you have the freshest data available every single day.
🔀 Diverse Endpoints: Whether you need to search by serial number, owner, or keyword, the API offers a wide variety of endpoints tailored for different use cases.
🛡️ Reliability: It abstracts away the instability often associated with direct government servers.
💎 Exclusive Data Access: It is currently the only API that returns detailed owner and attorney data, which is critical for legal tech and competitive intelligence.
🧠 Deep Search Capabilities: Beyond basic keywords, you can search specifically by owner, attorney, expiry date, and registration date.
🤖 MCP Supported: The API supports the Model Context Protocol (MCP), making it ready for immediate integration with modern AI agents.
💻 Developer Friendly: A full Postman Collection is available, allowing you to quickstart and test endpoints immediately without writing a single line of code.

🔍 Maximum Transparency: Unlike many "black box" APIs, this service provides a specific databaseStatus endpoint. This gives developers complete visibility into the state of the data, ensuring trust and reliability in your application's output.

{
  "last_update_date": "2026-02-02",
  "latest_trademarks": [
    {
      "keyword": "DIGITAL INFORMATION GOVERNANCE",
      "registration_number": "0000000",
      "serial_number": "99559923",
      "status_label": "Live/Pending",
      "registration_date": "2026-02-17"
    }
    ...
  ]
}

For developers building serious applications who need a "set it and forget it" solution that just works, this is the top recommendation. See documented changelog.

2. Atom Trademark Search

The Runner-Up

Atom (formerly branding or domain focused services usually associated with this name) offers a trademark search API that serves as an alternative.

The Downsides:

Less Transparent: Compared to the pentium10 data status transparency, it can be harder to verify exactly how fresh the data is at any given moment.
Cost & Usage: While it provides the logic needed, the cost structure and API limits are often less favorable for high-volume or startup-friendly use cases compared to the flexibility found on RapidAPI.
Focus: Their primary focus may not be purely on providing a raw, developer-centric data pipeline but rather supporting their own ecosystem, which can limit flexibility.

3. Official USPTO API

The "Avoid at All Costs" Option

Technically, the United States Patent and Trademark Office offers their own API. However, for a production environment, it is widely discouraged.

Why Developers Stay Away:

Technical Difficulty: It is technically very hard to implement and maintain. The documentation can be obscure, and the data structures are often convoluted.
Instability: "People complaining on Reddit" is a common theme. Downtime, rate limiting, and broken endpoints are frequent grievances in developer communities.
Legacy Issues: It often suffers from legacy infrastructure problems that modern APIs solve.

Verdict: Unless you have a team dedicated solely to maintaining the connection and parsing the data, the official API is generally not worth the headache.

Comparison Summary

Feature	USPTO API (RapidAPI)	Atom Trademark Search	Official USPTO API
Reliability	High (99.9% Uptime)	Medium	Low (Frequent Downtime)
Ease of Implementation	Very Easy (Postman Ready)	Moderate	Difficult
Owner/Attorney Data	Yes	Limited	Raw / Hard to Parse
Data Freshness	Daily Updates	Varies	Daily
Transparency	High	Low	Open Data
AI Ready (MCP)	Yes	No	No
Rate Limits	High	High	Very-Low
Average Cost	Flexible / Pay-per-use	Subscription / High	Free (High Maintenance Cost)

Conclusion

For most developers, the USPTO Trademark API on RapidAPI offers the best balance of power, price, and ease of use. The ability to search by attorney, owner, and keyword, combined with MCP support and a ready-to-use Postman collection, makes it the superior choice for modern application development.

Exhibit: Endpoint Availability

The following table details the specific endpoints available on the USPTO Trademark API (RapidAPI) and their availability on competing platforms.

Endpoint / Feature	USPTO API (RapidAPI)	Atom Trademark Search	Official USPTO API
Keyword Search	✅	✅	✅
Serial Number Search	✅	✅	✅
Registration Number Search	✅	✅	✅
Owner Search	✅	❌	❌
Attorney Search	✅	❌	❌
Filing Date Search	✅	❌	⚠️ (Complex)
Registration Date Search	✅	❌	⚠️ (Complex)
Expiry Date Search	✅	❌	❌
Database Status	✅	❌	✅

Legend: ✅ = Fully Supported, ❌ = Not Supported / Not Public, ⚠️ = Technically possible but difficult to implement.