Skip to main content

AI agents as Code, on a managed backend

Platform to build and scale agents inside your product

Calljmp runs your agents next to your existing backend, so you can add product copilots and other AI features without building new infrastructure.

Long-running, stateful agents with HITL

Secure access to your app's data and APIs

Traces, logs, and costs in one place

Launch an embedded product copilot

Lives inside your app, uses your real data, and runs on a managed agentic backend.

1.

Connect tools & data

Expose your existing APIs, DB queries, and services as tools.

2.

Define the copilot in TypeScript

Model the agent's behavior, tools, and guardrails as TypeScript code.

3.

Embed in your product UI

Call the copilot via SDK / HTTP and render it in your app panel.

Product copilot
U
User
How do I configure data retention for the new analytics module?
C
Copilot
Based on your plan and docs, you can adjust data retention under Settings > Analytics > Data Policies. The default is 90 days, but you can extend it up to 365 days.
Agent in TypeScript
import { workflow, llm } from '@calljmp/agent';

export function run(input: { message: string }) {
  return workflow.phase(
    'Copilot'
    () => llm.generate({
      input: [
        {
          role: 'system',
          content: 'You are a copilot for a dashboard',
        },
        {
          role: 'user',
          content: input.message,
        },
      ],
      memory: memory.short.context(),
    })
  );
}

Turn copilot project into a foundation for AI across your organization

Later, run support, marketing, and finance agents on the same backend - reusing tools, memory, and evals

Where Calljmp sits in your architecture

See how Calljmp integrates into your existing system and what responsibilities each side owns.

UsersYour product(web / mobile app)Your app backend(product logic, auth, billing)HTTPS / REST APICalljmp agent backendAgents as TypeScriptManaged executionHITL & observabilityREST / GraphQL / gRPC / DB driversInternal systems exposed as toolsYour app backend (as a tool)CRM / ticketingDocs / knowledge storeOther services / DBs

You own

  • Product UI & UX
  • Business logic, APIs, database
  • Data models & permissions

Calljmp owns

  • Agent execution & scaling
  • State, retries, timeouts, HITL
  • Traces, logs, metrics, cost tracking
Keep your backend clean
Your app backend stays focused on product logic, not LLM plumbing and long-running jobs.
Offload agent complexity
Calljmp handles agent execution, state, retries, timeouts, and HITL on a managed backend.
Connect all your systems
Agents call your vetted APIs, databases, and services as tools through a single agentic backend.

Evaluation for devs and ops, built into the runtime

Test, monitor, and improve your agents with built-in evaluation tools. Ship changes with confidence and keep quality under control.

For developers

Ship changes with confidence

  • See every step of an agent run with inputs, tools, and outputs
  • Text new prompts, tools, or models, and see how they perform
  • Debug failures with detailed traces

For ops & product

Keep quality and risk under control

  • Track regressions over time on critical metrics
  • Compare models and prompt versions on the same eval sets
  • Get a clear audit trail of why an agent responded the way it did

Capture real traces

Log every agent run step-by-step

Turn traces into evals

Create reusable test sets from production data

Test before you ship

Validate changes against saved evals.

Build faster with Calljmp's agentic primitives

Calljmp gives you the core building blocks for production AI agents — without forcing you into a visual builder or a custom backend. Compose these primitives in TypeScript and let the runtime handle the heavy lifting.

Runtime & workflows

Long-running, stateful runs

Memory & context

Summaries and long-term state

Tools & connectors

APIs, DB, services as tools

Human-in-the-loop

Approvals and reviews

Observability

Traces, logs, costs

Run agents as one unified backend

Develop, deploy, and manage your agentic logic in a single, consistent environment. Calljmp handles the infrastructure, scaling, and orchestration of complex workflows, ensuring reliability and performance without the operational overhead.

Agent runtime
import { workflow, llm, datasets, memory } from '@calljmp/agent';
import { z } from 'zod';

export function run(input: { message: string }) {
  return workflow.phase(
    'Chat',
    () => lm.generate({
      input: [
        {
          role: 'system',
          content: 'You are a copilot for a dashboard.',
        },
        {
          role: 'user',
          content: input.message,
        },
      ],
      memory: memory.short.context(),
      tools: [
        llm.tool({
          name: 'queryKnowledgeBase',
          description: 'Search product documentation and knowledge',
          parameters: z.object({
            query: z.string(),
          }),
          execute: async ({ query }) => {
            const { segments } = await datasets.query(query);
            return segments.map(segment => segment.content).join('\n---\n\n');
          },
        }),
      ],
    })
  );
}

Give your agents better context

Empower your agents with comprehensive and relevant information. Calljmp provides a flexible system for ingesting, indexing, and retrieving data from various sources, ensuring your AI models have the context they need for accurate and helpful responses.

Examples
Docs / knowledge
Chat history
Memory
Instructions
1
2
3

Your future agentic infrastructure on one backend

Multiple agents, one runtime: Product, support, marketing, and finance agents share the same execution, state, and observability layer.

Shared tools and data access: Each agent calls the same vetted tools to reach CRMs, billing, data warehouse, ticketing, and more.

Central governance & evaluation: One place to monitor behavior, run evals, and roll out changes across all agents.

In-app UI / chat / SDKREST / GraphQL / gRPC / DB driversEnd usersSupport teamMarketing teamFinance teamCalljmp agentic backendProduct copilotSupport agentMarketing analystFinance ops agentAgents as TypeScriptShared toolsManaged executionEval & observabilityProduct API / DBCRM / ticketingBilling / finance systemData warehouse / BIDocs / knowledge base

Why not just your backend or a visual builder?

Most teams either bolt agents onto their existing backend or try a visual builder. Calljmp gives you a dedicated, code-native agentic backend next to your app backend.

DIY in inside your main backend

  • Long-running jobs and pauses are painful
  • LLM plumbing mixed with normal business logic
  • Scaling, timeouts, queues – all your problem

Calljmp: code-native agentic backend

  • Agents as TypeScript in your repo
  • Dedicated runtime for long-running, stateful agents with HITL
  • Clean tools to call your APIs, DB, services
  • Traces, logs, and costs in one place

Visual builders / agent studios

  • Good for simple prototypes
  • Hard to express complex logic and edge cases
  • Limited version control, testing, and deep integration

Build, run, and scale faster with edge-native orchestration

Build AI agents and workflows as code directly in TypeScript, deploy them instantly to the Cloudflare Edge, and connect to your data sources with zero configuration.

Memory

Persistent and queryable context, shared across agents. Durable storage with zero cold starts.

Knowledge

Attach domain data to any agent using built-in vector and hybrid search. Works with your own documents, APIs, or databases.

Prompt
Planning
Reasoning
Reflection

Reasoning

Design complex multi-step logic as code, with observability at every phase. View traces, logs, and outputs directly from the Calljmp dashboard.

Human in the loop

Integrate approvals, manual feedback, and reviews into any agent flow. Seamlessly combine automation and oversight without extra infrastructure.

Trusted by developers

Accelerate AI-enabled app development with TypeScript - defined agents and workflows.

Simple, transparent pricing

Flexible pricing for AI agents and workflows as code. Start free, scale with predictable costs.

Agent actions

Agent run, dataset query, web fetch and extract

Price

$0.01

Included

Solo: 1,000/month · Pro: 10,000/month

LLM tokens

AI model inference per 1k tokens

Price

$0.011

Included

Pay-as-you-go

Dataset segments

Pages, sheets, or documents indexed

Price

$0.05

Included

Pay-as-you-go

Workflow phases

Multi-step workflow executions

Price

Free

Included

Unlimited

From our blog

Insights, tutorials, and stories from the world of AI agents and workflows as code. Learn how to build better apps with less complexity.

Your future agentic infrastructure

Run support, marketing, and finance agents on the same backend - reusing tools, memory, and evals

Frequently asked questions

Find answers to common questions about Calljmp's features, pricing, and capabilities.