PydanticAI + Gonka — typed AI agents for pennies

First, get a key: register at gate.joingonka.ai/register — we provide 10M free tokens upon registration — and create a key jg-xxx in Dashboard → API Keys.

Installation:

pip install pydantic-ai
# or a lightweight version with only OpenAI dependencies:
# pip install "pydantic-ai-slim[openai]"

A minimal example — an agent via Gonka. PydanticAI sets a custom endpoint via OpenAIProvider(base_url=..., api_key=...), which is passed to OpenAIChatModel:

from pydantic_ai import Agent
from pydantic_ai.models.openai import OpenAIChatModel
from pydantic_ai.providers.openai import OpenAIProvider

model = OpenAIChatModel(
    "MiniMaxAI/MiniMax-M2.7",
    provider=OpenAIProvider(
        base_url="https://gate.joingonka.ai/v1",
        api_key="jg-your-key",
    ),
)

agent = Agent(model)

result = agent.run_sync("Explain in two sentences what PoUW is")
print(result.output)

That's all — your PydanticAI agent works via the decentralized Gonka network for pennies. The run_sync method is convenient for scripts; for async code there is await agent.run(...).

Model parameters: the network model context window is 200K tokens (200000), and the maximum response length via Gateway is up to 8192 tokens. You can limit the output via model settings (OpenAIChatModelSettings(max_tokens=8192)). moonshotai/Kimi-K2.6 and MiniMaxAI/MiniMax-M2.7 are also available (up to 8192 output tokens each) — just change the model name in the first argument of OpenAIChatModel.

The main reason to choose PydanticAI is structured output. Instead of parsing the response text with regex, you describe the result as a Pydantic model and pass it to the output_type parameter. The framework uses the model's tool calling to force it to return data strictly according to the schema, validates it, and provides a ready-made object via result.output.

from pydantic import BaseModel
from pydantic_ai import Agent
from pydantic_ai.models.openai import OpenAIChatModel
from pydantic_ai.providers.openai import OpenAIProvider

model = OpenAIChatModel(
    "MiniMaxAI/MiniMax-M2.7",
    provider=OpenAIProvider(
        base_url="https://gate.joingonka.ai/v1",
        api_key="jg-your-key",
    ),
)


class Profile(BaseModel):
    name: str
    role: str
    skills: list[str]


agent = Agent(model, output_type=Profile)

result = agent.run_sync(
    "Extract data: Anna is a backend developer, knows Python, Go and Postgres"
)
print(result.output)
# name='Anna' role='backend developer' skills=['Python', 'Go', 'Postgres']
print(result.output.skills)  # ['Python', 'Go', 'Postgres'] — it's already a list[str], not text

This works because both Gonka models (Kimi K2.6 and MiniMax M2.7) support native tool calling — PydanticAI relies on this to return a valid JSON structure. As a result, you get a typed Python object rather than a string that needs to be parsed manually. Ideal for data extraction, classification, form filling, and RAG pipelines, where the result needs to flow further through the code in a strict format.

PydanticAI is a framework for agents and pipelines that operate continuously: extracting data, invoking tools, and processing streams of requests. Here, token costs determine whether a project remains a prototype or goes into production. Let's compare typical loads:

The difference is hundreds and thousands-fold. For a prototype, it means 10M free tokens are enough for hundreds of agent runs. For production handling hundreds of thousands of requests per day, the savings reach tens of thousands of dollars per month—using the same PydanticAI code, just with a different base_url.

A single jg-xxx key and one balance work for both the OpenAI format (/v1) and the Anthropic format (/v1/messages)—but for PydanticAI, the OpenAI-compatible endpoint shown above is sufficient.

The second key capability of PydanticAI is tools. A function can be registered using the @agent.tool_plain decorator (without context) or @agent.tool (with access to RunContext and dependency injection). The model decides for itself when to invoke a tool, receives the result, and continues its reasoning:

import random
from pydantic_ai import Agent
from pydantic_ai.models.openai import OpenAIChatModel
from pydantic_ai.providers.openai import OpenAIProvider

model = OpenAIChatModel(
    "MiniMaxAI/MiniMax-M2.7",
    provider=OpenAIProvider(
        base_url="https://gate.joingonka.ai/v1",
        api_key="jg-your-key",
    ),
)

agent = Agent(
    model,
    instructions="You are a helper. Use tools when necessary.",
)


@agent.tool_plain
def roll_dice() -> str:
    """Rolls a six-sided die and returns the result."""
    return str(random.randint(1, 6))


@agent.tool_plain
def calculator(expression: str) -> str:
    """Calculates a mathematical expression."""
    return str(eval(expression))


result = agent.run_sync("Roll the die and multiply the result by 7")
print(result.output)

Since tool calling in Gonka is native, tools are invoked reliably—without fragile parsing of text responses. The entire cycle (request → tool call → final response) costs about $0.00007 via Gonka compared to $0.04–0.22 with OpenAI/Anthropic.

Which model to choose: moonshotai/Kimi-K2.6 — strong in coding and complex reasoning, output up to 8192. MiniMaxAI/MiniMax-M2.7 — for long dialogues and balanced tasks, output up to 8192. Both are available right now using a single key—only the model string changes. Tools similar in spirit: LangChain for chains and RAG, LlamaIndex for data indexing.