Agentic Coding Starter Kit

By default, the AI SDK's streamText function stops generation after the first step when tool results are present (equivalent to stopWhen: stepCountIs(1)). To allow a model to use tool results to perform further reasoning or call additional tools (e.g., calling a weather tool and then a conversion tool), you must increase the stopWhen condition.

Use stepCountIs(n) to allow the model up to n steps of interaction (tool calls and subsequent model generations) within a single request. This enables complex multi-step workflows where the model gathers information and processes it sequentially.

import { streamText, stepCountIs } from "ai";

// ... inside your POST handler
const result = streamText({
  model: openrouter("openai/gpt-5-mini"),
  messages: convertToModelMessages(messages),
  stopWhen: stepCountIs(5), // Allows up to 5 steps of tool usage/reasoning
  tools: {
    // ... your tools
  },
});

The AI SDK supports different output strategies to define the shape of the generated data:

• object (Default): Returns the data as a single object. No explicit setting required.
• array: Generates an array of objects. The schema should define the shape of a single element in that array. When using streamObject, you can use elementStream to iterate over individual elements as they are generated.
• enum (Available with generateObject only): Used for classification tasks. Provide a list of allowed values in the enum parameter.
• no-schema: Used when you want structured output but don't want to enforce a specific schema (e.g., for dynamic user requests).

// Array strategy example
const { elementStream } = streamObject({
  model: openai("gpt-4.1"),
  output: "array",
  schema: z.object({
    name: z.string(),
    class: z.string().describe("Character class, e.g. warrior, mage, or thief."),
    description: z.string(),
  }),
  prompt: "Generate 3 hero descriptions for a fantasy role playing game.",
});

for await (const hero of elementStream) {
  console.log(hero);
}

// Enum strategy example
const { object } = await generateObject({
  model: "openai/gpt-4.1",
  output: "enum",
  enum: ["action", "comedy", "drama", "horror", "sci-fi"],
  prompt: "Classify the genre of this movie plot...",
});

// No-schema example
const { object } = await generateObject({
  model: openai("gpt-4.1"),
  output: "no-schema",
  prompt: "Generate a lasagna recipe.",
});

The starter is optimized for agentic workflows using files like AGENTS.md, CLAUDE.md, and DESIGN.md to provide context and rules.

Recommended Workflow

1. Planning Mode: Describe your app in plain language. Let the agent ask clarifying questions and confirm a plan (goals, scope, constraints).
2. Edit Mode: Ask the agent to implement the plan. The agent should split work into parallel streams or feature chunks.
3. Verification: The agent should run lint, typecheck, and build before finishing.

Starter Prompt

Use this prompt to initialize your agent:

I am using the Agentic Coding Starter Kit. Treat the existing app as boilerplate that should be replaced by the product I describe.

Use the project instructions in AGENTS.md or CLAUDE.md. During planning, ask clarifying questions before making assumptions. During implementation, split the work into small chunks, use sub-agents where useful, follow DESIGN.md for UI, preserve the existing tech stack unless there is a good reason to change it, and run lint, typecheck, and build before finishing.

What I want to build:
[Describe your app here]

To create a backend endpoint for streaming AI responses in Next.js, use the streamText function from the ai package and the toUIMessageStreamResponse method from the StreamTextResult object.

Workflow:

1. Extract Messages: Receive UIMessage[] from the request body.
2. Convert Messages: Use convertToModelMessages(messages) to strip UI-specific metadata (like timestamps) and convert them into the ModelMessage[] format required by the LLM.
3. Initialize Provider: Use a provider like createOpenRouter to initialize the model.
4. Stream Text: Call streamText with the model and converted messages.
5. Return Response: Return result.toUIMessageStreamResponse() to enable streaming to the client.

Configuration Tip: Use export const maxDuration = 30; to allow longer-running streaming requests in Next.js.

import { createOpenRouter } from "@openrouter/ai-sdk-provider";
import { streamText, convertToModelMessages } from "ai";

export const maxDuration = 30;

export async function POST(req: Request) {
  const { messages } = await req.json();
  const openrouter = createOpenRouter({ apiKey: process.env.OPENROUTER_API_KEY });

  const result = streamText({
    model: openrouter(process.env.OPENROUTER_MODEL),
    messages: convertToModelMessages(messages),
  });

  return result.toUIMessageStreamResponse();
}