Get started with Brinpage.

Brinpage is an AI infrastructure platform for building and running AI agents across company data and tools.

The core idea behind Brinpage is simple: your app only needs to connect to a single API. After that, agents, tools, context modules, routing behavior, and provider execution are controlled from the platform. You do not need to hardcode all of that logic into your application.

In practice, this means you can go from integration to a working agent system in minutes. Instead of wiring models, prompts, providers, and tool behavior across multiple files, you connect Brinpage once and manage the rest from the panel without changing code every time your setup evolves.

This makes Brinpage especially useful for production teams that want real operational control. Your product sends requests. Brinpage handles execution through a centralized platform where you can configure how agents behave, what tools they can use, what context they receive, and how requests are routed across different models.

Brinpage is designed so your application does not need to manually orchestrate every part of the agent stack. You do not need separate logic for provider selection, model routing, context assembly, or tool execution spread across your codebase.

Instead, your application links the Brinpage API once. From there, the platform becomes the control plane for your agents. You can define instructions, attach tools, connect context modules, and adjust routing behavior from the panel, without rewriting the integration each time.

This is an important architectural difference. Your code is responsible for sending the request. Brinpage is responsible for running the agent system around that request.

Getting started with Brinpage is intentionally lightweight. The setup flow is designed so you can connect your app quickly and move agent configuration into the platform from the beginning.

A typical flow looks like this:

The key point is that the setup effort stays small. You are not building a large orchestration layer inside your own backend before you can ship. Brinpage gives you the execution layer first, and the platform lets you evolve it without constant code changes.

Your application authenticates once with Brinpage Platform. These variables connect your app to the execution layer, but they do not define agent behavior.

BRINPAGE_LICENSE_KEY=bp_xxxx
BRINPAGE_API_BASE=https://platform.brinpage.com
BRINPAGE_ASK_TIMEOUT_MS=30000

This is another place where Brinpage stays intentionally simple. You connect your app once, and the platform takes care of the agent configuration layer separately.

Once the environment is configured, your backend only needs to send the request. The route itself stays small because Brinpage handles the execution system behind it.

import { NextResponse } from "next/server"
import { ask } from "@/lib/brinpage"

export async function POST(req: Request) {
  const { messages, question, context } = await req.json()

  const result = await ask({
    question,
    messages,
    context,
  })

  return NextResponse.json(result)
}

This endpoint does not contain your provider logic, tool registry, or routing rules. It only forwards the request to Brinpage. That is exactly the point. Your code stays clean, while the platform stays in charge of the operational complexity.

curl -X POST https://platform.brinpage.com/api/sdk/ask \
  -H "Authorization: Bearer $BRINPAGE_LICENSE_KEY" \
  -H "Content-Type: application/json" \
  -d '{"question":"Hello from Brinpage","stream":false}'

After linking the API, the main workflow moves to Brinpage Platform. This is where you configure and operate your agent system without continuously editing backend code.

This is one of the most important ideas in Brinpage: the API integration is stable, while the behavior of the agent system remains editable from the platform. That means you can iterate faster and keep control without turning your product code into a brittle orchestration layer.

Brinpage can route requests dynamically across available models depending on what you want to optimize for. This lets you keep one API surface while adapting execution to different workloads and priorities.

The important part is that this routing behavior is configured from the platform. You do not need to hardcode model selection logic into each route or rebuild your own switching layer every time you want a different execution strategy.

Brinpage supports multiple providers through one platform and one execution layer. Instead of maintaining separate integrations for each vendor, you connect once and execute through Brinpage.

This multi-provider design is useful both technically and operationally. It helps keep your integration stable over time while allowing routing and provider strategy to evolve from the platform instead of being tightly coupled to your app.

Brinpage agents are built from modular components that can be configured from the platform and reused across applications and internal workflows.

Instructions shape how agents respond. Tools give them capabilities. Context modules let you attach reusable knowledge only when needed, which helps keep execution more precise and easier to maintain.

This modular structure matters because it avoids mixing every concern into one large prompt or one rigid implementation. You can evolve each part of the system independently while still running everything through the same API surface.

Brinpage uses usage-based pricing. To make sure the documentation always reflects the latest pricing model, current pricing is available on the pricing page instead of being hardcoded here.

Brinpage is built around a very simple integration model: connect the API once, then manage the real agent infrastructure from the platform.

That includes agents, tools, context modules, routing, and multi-provider execution. Your app stays clean. The platform stays in control. And the whole system can be configured in minutes without repeatedly rewriting your codebase.