The stack we use internally.

Studio, SDKs, the workflow server, the eval system, two-way MCP. The same platform that runs every workflow Podesta delivers under a services engagement — licensed for your team to build on.

Five surfaces, one stack.

Instantiate the client. Call the workflow. Get typed output.

import { AkribesClient } from "akribes-sdk-ts";

const client = new AkribesClient({
  baseUrl: "https://podesta.example.com",
  token: process.env.PODESTA_API_KEY!,
  projectId: 1,
});

const run = client.executions.runStream("contract-clause-extract", {
  inputs: { document: pdfBytes, locale: "en-GB" },
});

const output = await run.output;
// output is typed against the workflow's declared output schema.
console.log(output);

import asyncio, os
from akribes_sdk import AkribesClient

async def main() -> None:
    async with AkribesClient(
        base_url="https://podesta.example.com",
        project_id=1,
        token=os.environ["PODESTA_API_KEY"],
    ) as client:
        _id, output = await client.executions.run_and_await(
            "contract-clause-extract",
            inputs={"document": pdf_bytes, "locale": "en-GB"},
        )
        # output.result is typed against the workflow's declared output schema.
        print(output.result)

asyncio.run(main())

use akribes_sdk_rust::AkribesClient;

#[tokio::main]
async fn main() -> akribes_sdk_rust::Result<()> {
    let client = AkribesClient::builder("https://podesta.example.com")
        .project_id(1)
        .token(&std::env::var("PODESTA_API_KEY")?)
        .build();

    let (_id, output) = client
        .project(1)
        .executions()
        .run("contract-clause-extract")
        .execute_and_await(None)
        .await?;

    // output.result is typed against the workflow's declared output schema.
    println!("{:?}", output.result);
    Ok(())
}

Three things stay out of your codebase.

Consume tools. Export your workflows.

MCP is first-class in both directions. A workflow consumes external MCP servers as typed tools (databases, third-party SaaS, anything that speaks the protocol). And a workflow can be exported as an MCP tool — your Akribes script becomes something another team's agent, or another company's, can call without touching your code.

We use the same stack to deliver services.

Every workflow Podesta ships under a services engagement runs on the stack you'd license. We didn't extract Akribes from a side project — we built it for the platform that runs our customer work. The type system, the eval surface, cross-script composition, document ingestion, the audit trail: each piece exists because we needed it to ship correct AI behaviour at scale.

BDPE's first production workflow runs on it. So does the chain that handles their inbound mail. So does the internal evaluation harness — 27 cases, a deterministic judge, the same score that gates every change we ship.

Three options. Same stack.