Stop fighting CloudFormation. Deploy serverless functions with a single POST. Millisecond warm invokes. Scale-to-zero when idle. Per-invocation billing. No vendor lock-in.
Lambda deploys are a 7-step pipeline across 3 AWS services. TauFunctions is one HTTP request with your code inline. Deploy in seconds, invoke in milliseconds, pay per invocation.
7 steps. 3 services. 5 minutes. Every time.
POST /tau/functions — code inline, deployedPOST /tau/functions/:id/invoke — executed1 step. 1 service. Seconds. Every time.
The serverless platform that gets out of your way.
Whether you're a solo developer prototyping, a team running CI/CD pipelines, or an enterprise sharing compute across organizations — it's the same API.
Create, deploy, and invoke functions via a single API call. Your agent sends the code inline — TauFunctions builds the container and returns the invoke URL.
Three Node.js runtimes live today on optimized container images. Python, Go, Ruby, and Rust are rolling out next. Your agent picks the runtime, TauFunctions handles the rest.
Each function runs as a real Docker Swarm service that scales to zero when idle — you pay nothing between invocations. Warm handlers execute in single-digit milliseconds.
Real-time execution logs, invocation stats, error tracking. Every invocation metered. No CloudWatch setup, no third-party APM required.
Per-project API keys and resource limits. Each tenant gets isolated function namespaces, separate metering, and team API key management.
Invoke over HTTP from anywhere — curl, CI/CD, webhooks pointed at your invoke URL, or the CLI. Cron and event triggers are on the roadmap.
npm i -g taufunctions — the zero-dependency tau CLI covers the full lifecycle, and tau mcp-serve exposes 37 MCP tools so Claude Code, Cursor, and friends deploy natively.
Per-tenant usage tracking. Team API key management. Real-time billing dashboard. Pay only when functions execute.
Coming to Enterprise: share functions across organizations via tyga.network contracts and invoke functions in partner tenants. Bilateral. Secure. Audited.
Coming to Enterprise: publish functions to a shared marketplace where other tenants discover and invoke them. Your brand, your pricing, your functions.
EU AI Act compliant logs. Every agent action audited with actor, timestamp, state change. Custom runtimes. Dedicated clusters. Export for regulators.
Real terminal sessions against the live platform — no mockups. Pick a scenario below.
Your agents drive each loop. You set direction, review outputs, and keep full visibility.
Your agent sends the code inline with the runtime config, then deploys. TauFunctions provisions a dedicated Docker Swarm service and returns a live invoke URL. No zip, no S3, no CloudFormation.
POST /tau/functions
{
"name": "process-order",
"runtime": "nodejs20",
"handler": "index.handler",
"code": "exports.handler = async (event) => {\n return { status: 'processed', orderId: event.orderId };\n}"
}
// Response: { "functionId": "taufn-a1b2c3d4-...", "status": "inactive", ... }
POST /tau/functions/taufn-a1b2c3d4-.../deploy
// Response: { "status": "active",
// "deployment": { "serviceName": "tau-fn-taufn-a1b2c3d4-...",
// "invokeUrl": "https://fn-taufn-a1b2c3d4-....tau.agentsme.ai" } }
One POST — your JSON body is the event your handler receives. TauFunctions executes in an isolated container, logs every invocation durably, returns the result. Single-digit-ms handler execution when warm.
POST /tau/functions/:id/invoke
POST /tau/functions/taufn-a1b2c3d4-.../invoke
{
"orderId": "ORD-001",
"items": [{"sku": "WIDGET-X", "qty": 3}]
}
// Response:
// { "success": true, "statusCode": 200,
// "body": "{\"status\":\"processed\",\"orderId\":\"ORD-001\"}",
// "duration": 2, "requestId": "req-a1b2c3d4",
// "executor": "container" }
Install the zero-dependency CLI and your agent gets the whole platform: functions, deploys, invokes, logs, stats. tau mcp-serve exposes it all as native MCP tools. Idle functions scale to zero automatically.
npm install -g taufunctions
# Full lifecycle from the terminal
tau fn create "process-order" -r nodejs20 --file index.js
tau deploy taufn-a1b2c3d4-...
tau invoke taufn-a1b2c3d4-... '{"orderId":"ORD-001"}'
tau logs taufn-a1b2c3d4-... --tail 50
tau stats taufn-a1b2c3d4-...
# Or hand it to your coding agent as MCP tools
tau mcp-serve
AWS Lambda charges per request + compute time + data transfer + API Gateway. We charge $0.10 per million invocations. That's it.
Complex pricing, no agent API
One price, one API call
Git-push only, limited runtimes
"Developers shouldn't spend more time deploying a function than writing it. With Lambda, they do. Every time. We built TauFunctions so you can focus on what your code does — not how it gets there. One API call and your function is live. That's it. Ship faster. Ship more. Let the platform worry about infrastructure."
Lambda charges for compute time + requests + data transfer + API Gateway. TauFunctions: one price per invocation. Start free.
1 developer, 1 project
For production workloads
For teams and pipelines at scale
Your infrastructure, our platform
$1 verification fee on signup — credited to your first subscription or refunded on request.
No AWS account. No CloudFormation. Just POST your code and it's live. Millisecond warm invokes, scale-to-zero idle, $0.10 per million invocations. $1 verification on signup — credited or refunded.
