Skip to content
Jev + Agentium: decisions, tools, and evaluations.See how
Agentium

Agentium / TypeScript agent framework

Your next big thing.Built with agents.

Agentium is a TypeScript agent framework for Node.js. Bring models, tools, memory, and workflows together in one framework. Everything connected, ready for you to build.

Start buildingExplore the stack
npm install @agentium/core

Start with core. Add the integrations your application needs.

  • One TypeScript framework
  • Choose your models
  • Keep your infrastructure
  • Typed tools with Zod
  • Memory you configure
  • Teams and workflows
  • Jev typed decisions
  • Approval gates
  • Budget checks
  • Tracing and metrics
  • Evaluation package
  • MCP and A2A
  • Voice and browser agents

One framework, connected parts

Everything around the model,working together.

A useful agent needs context, tools, coordination, and a way into your product. Build those pieces around a shared TypeScript foundation.

Your agent application

6 connected parts

Start small. Add capabilities without changing the foundation.

Start with TypeScript

Your first agent should look familiar.

Define its job, choose a model, and run it. Add capabilities when the work calls for them.

Read the quickstart

first-agent.ts

import { Agent, openai } from "@agentium/core";

const productGuide = new Agent({
  name: "product-guide",
  model: openai("gpt-6-astra"),
  instructions: "Explain technical ideas with one concrete example.",
});

const answer = await productGuide.run(
  "When should an agent use a tool?",
);

console.log(answer.text);
Install
npm install @agentium/core openai
Server-side env
OPENAI_API_KEY
Note
Run TypeScript locally with tsx in an ESM project.
Open guide

Jev + Agentium

Let the model talk.Let Jev make the call.

Add Jev’s typed decisions to your Agentium application. Use it to choose a route, give a chat agent a judgment tool, or score a response in an evaluation.

Build with JevRead the integration guide

  • Make the decision

    Pass context and a defined set of questions. Get decisions your code can use.

    Model integration

  • Give your agent a second opinion

    Let a chat agent call Jev when it needs a label, probability, or rubric score.

    Jev toolkit

  • Put judgments into your evals

    Score generated responses against criteria you define.

    Evaluation guide

See a decision flow

Illustrative example

Input

“My invoice shows the same charge twice.”

Question · choice()

Which team should receive this?

Output

billingtechnicalother

Example choice label.

Your application decides what happens with the result.

Build the application

The parts you need, already connected.

Give your agent context and useful tools. Bring in specialists when one agent is not enough.

Memory01

Keep the context that matters.

Save sessions, keep useful facts, and bring relevant context into the next conversation. Configure the storage behind it.

Explore memory

Tools02

Let agents do useful work.

Give your agents typed tools, reusable skills, and access to the services your product already uses.

Explore tools

Teams03

Give each specialist a job.

Route a request, delegate tasks, or bring multiple agents together around the same problem.

Explore teams

Workflows04

Make the steps explicit.

Combine agent work with functions, conditions, and parallel steps. Carry shared state through the process.

Explore workflows

Knowledge05

Bring your own knowledge.

Connect document retrieval to the agent’s tools so it can work with the information your application needs.

Explore retrieval

Harness06

Give the agent a working environment.

Add project instructions, skills, standing notes, and helper agents through the Agentium harness.

Explore the harness

How the pieces work together

Follow one request through the stack.

Context, decisions, tools, and human review belong in the same application flow.

01/ Context

Start with the right context.

Load the conversation and retrieve the information the agent needs.

Illustrative support workflowStep 01 / 04

Incoming request

“I need help with invoice A104.”

  1. 01 Context

    Context loaded

    • Account history

      Plan: Team · 14 months · 2 prior tickets

    • Invoice record

      A104 · issued this month · 2 line items

    Example data. Your storage and retrieval decide what loads.

  2. 02 DecisionNot started
  3. 03 ToolsNot started
  4. 04 ApprovalNot started

02/ Decision

Make a decision you can use.

Ask Jev to classify the request, then let your application choose the next step.

Illustrative support workflowStep 02 / 04

Incoming request

“I need help with invoice A104.”

  1. 01 ContextAccount history and invoice A104 loaded
  2. 02 Decision

    Typed decision

    Jev
    • Billing
    • Technical
    • Other

    Jev returns the label. Your application chooses the next step.

  3. 03 ToolsNot started
  4. 04 ApprovalNot started

03/ Tools

Let the agent use its tools.

Give the specialist access to the relevant API and prepare the response.

Illustrative support workflowStep 03 / 04

Incoming request

“I need help with invoice A104.”

  1. 01 ContextAccount history and invoice A104 loaded
  2. 02 DecisionJev classified the request as Billing
  3. 03 Tools

    Specialist at work

    lookup_invoice({ id: "A104" })completed

    Draft response

    I found invoice A104. The second line item looks like a duplicate of the first. I can issue a credit for it once a teammate confirms.

  4. 04 ApprovalNot started

04/ Approval

Keep important actions in human hands.

Require approval before a selected tool runs, then record what happened.

Illustrative support workflowStep 04 / 04

Incoming request

“I need help with invoice A104.”

  1. 01 ContextAccount history and invoice A104 loaded
  2. 02 DecisionJev classified the request as Billing
  3. 03 Toolslookup_invoice ran · draft response ready
  4. 04 Approval

    Human review

    issue_credit({ invoice: "A104" })Waiting for review

    The tool does not run until a reviewer decides. Nothing is called from this page.

Keep control as you grow

Know what ran. Decide what runs next.

Put approval rules around sensitive tools. Watch run events, check budgets, and test the behavior you care about.

  • Approval gates

    Require a human decision before selected tools execute.

    Read more

  • Budget checks

    Track usage and check configured budgets during a run.

    Read more

  • Run visibility

    Add tracing, metrics, and structured logs through the observability package.

    Read more

  • Evaluation

    Define test cases and score outputs before you change production behavior.

    Read more
  1. 01run.startagent · support-desk
  2. 02tool.calllookup_invoice
  3. 03tool.resultinvoice found
  4. 04run.completeresponse ready
Example lifecycle events. See run events.

Fits your stack

Choose your models. Keep your infrastructure.

Connect the providers, services, and storage your application needs. Bring external tools in through MCP and connect agents through A2A.

Models

Services

Storage & protocols

Explore integrations

Add the adapters and credentials you need for your chosen services.

What will you build?

Start with a job worth automating.

Explore patterns you can adapt to your own product.

Browse examples

A few things worth knowing.

Agentium is a TypeScript framework for building agent applications on Node.js. It brings together agent execution, tools, memory, teams, and workflows, with additional packages for serving, background work, browser automation, observability, and evaluation.

No. Agentium supports multiple providers and custom integrations. Choose models according to the task. Capabilities differ: a chat model, a realtime voice provider, and Jev’s decision model serve different purposes.

Use Jev directly for typed decisions, give a chat agent access to Jev through a toolkit, or use it to judge responses in an evaluation. Your chat model still handles the conversation when prose is needed.

Yes, with the relevant memory configuration and storage. Configure persistence for sessions and enable additional memory features as needed. In-memory storage does not survive a process restart.

Yes. Configure approval rules for selected tool calls and connect them to your application’s review flow.

This website describes the framework and its runtime integrations. You choose the infrastructure on which your application runs. Use the transport and queue guides to connect it to your deployment.

Start with the quickstart, run a small agent, and then add the tools or memory your use case needs. The examples page points to focused recipes.

Build the agent.Bring the whole stack.

Start with a few lines of TypeScript. Add the rest when you need it.

Open the quickstartExplore examples