MeerTech
PlatformOfferingsPortfolioDocsResearchCompany
Talk to us
Docs · SDKs
[ SDKs ]

Build agents in the language you already ship.

Four first-party SDKs wrap the MeerTech API. Every SDK gives you the same primitives — agents, tools, policy envelopes, runs, traces — and the same semantics. Pick the runtime that matches your systems of record.

PythonTypeScriptGoJava
01SDK matrix

Pick a runtime.

v1.4.2 · General availability

Python

python>=3.10

pip install meertech

v1.4.2 · General availability

TypeScript

node>=20

npm install @meertech/sdk

v0.8.0 · Beta

Go

go>=1.22

go get github.com/meertech/meertech-go@latest

v0.6.1 · Beta

Java

java>=17

implementation("tech.meertech:meertech:0.6.1")
02Python

First-class for data + finance teams.

The Python SDK mirrors the platform model: declare the agent, register tools with decorators, emit plans as Python functions. Async-first.

agents/reconciler.py

python

from meertech import Agent, policy, tool, context

@tool(provider="mcp.zoho_books", action="post_journal", idempotent=True)
async def post_journal(entry: dict) -> str:
    """Post a journal entry into Zoho Books. Returns the journal id."""

agent = Agent(
    name="finance.reconciler",
    role="finance.agent",
    policy=policy.envelope(
        scope=["post.journal", "reconcile.bank"],
        limit_usd=50_000,
        approvers=["controller.queue"],
        escalate_above_usd=25_000,
    ),
    tools=[post_journal],
)

@agent.plan
async def close_period(period: str):
    invoices = await context.invoices(period=period, status="open")
    for inv in invoices:
        decision = await agent.sentinel.evaluate("post.journal", inv)
        if decision.allow:
            await post_journal(inv.to_entry())
        else:
            await agent.escalate(inv, reason=decision.reason)

if __name__ == "__main__":
    agent.run(close_period, period="2026-04")
03TypeScript

Typed plans, typed tools.

The TypeScript SDK gives you end-to-end types from tool schemas through to run results. Zod schemas double as runtime validators for tool inputs.

src/reconciler.ts

typescript

import { z } from "zod";
import { Agent, policy, tool } from "@meertech/sdk";

const JournalEntry = z.object({
  vendor: z.string(),
  amount_usd: z.number(),
  period: z.string().regex(/^\d{4}-\d{2}$/),
});

const postJournal = tool({
  name: "zoho_books.post_journal",
  provider: "mcp.zoho_books",
  input: JournalEntry,
  output: z.string(),
  idempotent: true,
});

export const agent = new Agent({
  name: "finance.reconciler",
  role: "finance.agent",
  policy: policy.envelope({
    scope: ["post.journal", "reconcile.bank"],
    limitUsd: 50_000,
    approvers: ["controller.queue"],
    escalateAboveUsd: 25_000,
  }),
  tools: [postJournal],
});

agent.plan("close_period", async ({ inputs, context, sentinel }) => {
  const invoices = await context.invoices({ period: inputs.period, status: "open" });
  for (const inv of invoices) {
    const decision = await sentinel.evaluate("post.journal", inv);
    if (decision.allow) {
      await postJournal({ vendor: inv.vendor, amount_usd: inv.total, period: inputs.period });
    } else {
      await context.escalate(inv, { reason: decision.reason });
    }
  }
});
04Go

For infra and edge.

The Go SDK is tuned for connector sidecars and edge runtimes where binary size and startup time matter.

cmd/reconciler/main.go

go

package main

import (
    "context"
    "log"

    "github.com/meertech/meertech-go/agent"
    "github.com/meertech/meertech-go/policy"
    "github.com/meertech/meertech-go/tool"
)

type JournalEntry struct {
    Vendor    string  `json:"vendor"`
    AmountUSD float64 `json:"amount_usd"`
    Period    string  `json:"period"`
}

func main() {
    post := tool.New[JournalEntry, string]("zoho_books.post_journal",
        tool.Provider("mcp.zoho_books"),
        tool.Idempotent(true),
    )

    a := agent.New("finance.reconciler",
        agent.Role("finance.agent"),
        agent.Policy(policy.Envelope{
            Scope:            []string{"post.journal", "reconcile.bank"},
            LimitUSD:         50000,
            Approvers:        []string{"controller.queue"},
            EscalateAboveUSD: 25000,
        }),
        agent.Tools(post),
    )

    a.Plan("close_period", func(ctx context.Context, r *agent.Run) error {
        invoices, err := r.Context.Invoices(ctx, "2026-04", "open")
        if err != nil { return err }
        for _, inv := range invoices {
            dec, _ := r.Sentinel.Evaluate(ctx, "post.journal", inv)
            if dec.Allow {
                _, _ = post.Call(ctx, JournalEntry{inv.Vendor, inv.Total, "2026-04"})
            } else {
                _ = r.Escalate(ctx, inv, dec.Reason)
            }
        }
        return nil
    })

    if err := a.Run(context.Background()); err != nil {
        log.Fatal(err)
    }
}
05Java

For JVM enterprise stacks.

The Java SDK targets JVM 17+ and integrates cleanly with Spring and established enterprise observability stacks.

Reconciler.java

java

package ops;

import tech.meertech.Agent;
import tech.meertech.Policy;
import tech.meertech.Tool;

public final class Reconciler {
    static final Tool<JournalEntry, String> POST_JOURNAL =
        Tool.of("zoho_books.post_journal", JournalEntry.class, String.class)
            .provider("mcp.zoho_books")
            .idempotent(true)
            .build();

    public static void main(String[] args) {
        Agent agent = Agent.builder("finance.reconciler")
            .role("finance.agent")
            .policy(Policy.envelope()
                .scope("post.journal", "reconcile.bank")
                .limitUsd(50_000)
                .approver("controller.queue")
                .escalateAboveUsd(25_000)
                .build())
            .tool(POST_JOURNAL)
            .plan("close_period", run -> {
                var invoices = run.context().invoices("2026-04", "open");
                for (var inv : invoices) {
                    var decision = run.sentinel().evaluate("post.journal", inv);
                    if (decision.allow()) {
                        POST_JOURNAL.call(inv.toEntry());
                    } else {
                        run.escalate(inv, decision.reason());
                    }
                }
            })
            .build();

        agent.run();
    }
}
06Shared surface

What every SDK ships.

Agent declaration

name, role, policy envelope, tools, plans

Tool registry

typed input/output, provider binding, idempotency hints

Neural Grid client

structured queries, semantic search, graph traversal

Sentinel client

policy evaluation, escalation, approval waits

Run control

start, pause, resume, cancel, tail trace

Observability

OpenTelemetry spans, policy metrics, run-level metrics

07Industry playbooks

Reference configurations per sector.

The SDK packages ship reference configurations for each sector — finance, healthcare, energy, manufacturing, defense. Every playbook is a working agent skeleton with policy envelope, tool registrations, and Neural Grid connector wiring ready to adapt.

cli

bash

$ meer playbook list
→ finance.reconciler       · Zoho Books / SAP GL autonomous close
→ finance.fraud_triage     · card-present fraud case disposition
→ healthcare.bed_flow      · ICU allocation + transport dispatch
→ energy.outage_response   · SCADA fault triage + crew routing
→ manufacturing.yield_ops  · MES-driven quality disposition
→ defense.track_fusion     · radar + EO/IR + AIS track enrichment

$ meer playbook init finance.reconciler ./my-finance-agent
→ scaffolded 14 files. edit policy.yaml + connectors.yaml to finish.

Ship an agent this week.

Request a workspace, scaffold a playbook, run in shadow against your real systems — then graduate to live.

MeerTech
Autonomous decision infrastructure

Architecting agentic AI, FinTech, and cloud systems for the teams that intend to dominate their category.

Platform
OverviewIntelligenceOutcomesResources
Offerings
All offeringsPortfolioResearchImpact
Company
AboutMissionContactDocs

© 2026 MeerTech Ltd.
PrivacyTerms