PydanticAI + Gonka — typed AI agents for pennies

First, get your key: sign up at gate.joingonka.ai/register — when you register, we give you 3M free tokens — and create a jg-xxx key in Dashboard → API Keys.

Installation:

pip install pydantic-ai
# or the slim variant with only the OpenAI dependencies:
# pip install "pydantic-ai-slim[openai]"

A minimal example — an agent through 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 it — your PydanticAI agent runs through the Gonka decentralized network for pennies. The run_sync method is handy for scripts; for async code, use await agent.run(...).

Model parameters: MiniMax M2.7 has a 180K token context window (180000), DeepSeek V4 Flash has 380K, GLM-5.3 Flash has 390K; the maximum response length through the Gateway is up to 8192 tokens for MiniMax and GLM-5.3 Flash, up to 32768 for DeepSeek. You can limit the output via model settings (OpenAIChatModelSettings(max_tokens=8192)). Available models: MiniMaxAI/MiniMax-M2.7, deepseek-ai/DeepSeek-V4-Flash-0731, and zai-org/GLM-5.3-Flash — 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 regexes, 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 gives you 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 the data: Anna is a backend developer who knows Python, Go and Postgres"
)
print(result.output)
# name='Anna' role='backend developer' skills=['Python', 'Go', 'Postgres']
print(result.output.skills)  # ['Python', 'Go', 'Postgres'] — already a list[str], not text

This works because all three Gonka models (MiniMax M2.7, DeepSeek V4 Flash, and GLM-5.3 Flash) support native tool calling — PydanticAI relies on it to return a valid JSON structure. What you get is a typed Python object, not a string you have to parse by hand. Perfect for data extraction, classification, form filling, and RAG pipelines, where the output must flow onward through code in a strict format.

PydanticAI is a framework for agents and pipelines that operate continuously: extracting data, calling tools, and processing request streams. Here, token cost decides whether a project remains a prototype or goes into production. Let's compare typical workloads:

The difference is hundreds or thousands of times. For a prototype, this means the 3M free tokens are enough for the first agent runs. For production handling hundreds of thousands of requests per day, savings amount to tens of thousands of dollars per month — with the same code on PydanticAI, just with a different base_url.

One 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 PydanticAI feature is tools. You can register a function with the @agent.tool_plain decorator (no context) or @agent.tool (with access to RunContext and dependency injection). The model decides on its own when to call the tool, receives the result, and continues 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 an assistant. Use the tools when needed.",
)


@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:
    """Evaluates a math expression."""
    return str(eval(expression))


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

Since tool calling on Gonka is native, tools are invoked reliably — no fragile parsing of text responses. The whole cycle (request → tool call → final answer) costs about $0.00007 through Gonka versus $0.04–0.22 at OpenAI/Anthropic.

Which model to choose: MiniMaxAI/MiniMax-M2.7 — for long conversations and balanced tasks, output up to 8192. deepseek-ai/DeepSeek-V4-Flash-0731 — one of the longest contexts on the network (380K) and cheap large prompts, output up to 32768. zai-org/GLM-5.3-Flash — a reasoning model for complex deliberation and the longest context on the network (390K), output up to 8192; reasoning consumes part of max_tokens, so set it with headroom (from 600). All three are available right now with a single key — only the model string changes. Kindred tools: LangChain for chains and RAG, LlamaIndex for data indexing.