One workspace, the whole lifecycle
Build the agent. Prove it works. Watch every move it makes. Ship it anywhere.
Invoked is the local-first workspace where a team builds, runs, proves, and ships AI agents against their own tools, with the sensitive artifacts staying on the developer's machine, not a vendor's cloud. It's an agent builder. It's an eval suite. And it makes every agent observable from the first run: full traces, in the open standards your stack already speaks. One tool does the jobs you're currently buying three for.
The lifecycle
Five jobs, one workspace
You saw the agent builder and the evals. That's two of five. The whole product is the lifecycle, end to end, on your machine.
| Job | What it is | What it is not |
|---|---|---|
| Connect | Your own APIs & MCP servers become a callable "Surface" | A vendor tool catalog you're locked into |
| Build | A visual harness of agents + guardrails + tools | Only an agent builder (building is one job of several) |
| Run | Every step traced & replayable. Observability built in, not bolted on | Yet another vendor cloud you ship all your traces to |
| Prove | Model evals + behavioral assertions, built in | A standalone eval SaaS bolted on afterward |
| Ship | One-click portable code + OpenTelemetry traces. Run it on your infra, monitor it with your stack | A lock-in runtime that holds your agents hostage |
The compliance answer
Where the data actually lives
The short version: on the developer's machine. Invoked's servers hold only anonymized aggregates and, optionally, encrypted backups it can't read.
| Data | Where it lives | Leaves the machine? |
|---|---|---|
| API keys & tokens | OS keychain (macOS Keychain / Windows DPAPI) | Never. Encrypted, never on disk in plaintext |
| Prompts, runs, agent definitions, skills, harnesses | Local SQLite on the device (invoked.db) | Never, unless explicitly shared |
| Your API responses & tool outputs | In-memory during a run → local run history | Never |
| Anonymized telemetry (tool-call counts, latencies) | Tinybird (salted-hashed & aggregated) | Aggregate only. Never prompts, keys, or content |
| Optional backup | Cloudflare R2 (client-side AES-GCM encrypted before upload) | Ciphertext only. We can't read it |
Shared vs. local
How teams collaborate in Invoked
Sharing is deliberate, never automatic. A team gets shared tools and agent recipes plus pooled reliability metrics, without anyone's keys or private runs leaving their device.
- Default: everything is personal + local. One developer, their machine. Nothing is shared until they choose to.
- Sharing moves the recipe, not the secrets. A developer can share a surface, skill, or harness to the team. Only the definition travels (the tool config, the harness graph). Credentials never travel; they stay in each person's keychain.
- Metrics pool; content stays put. Per-surface reliability & latency aggregate across the team so everyone sees what actually works, but the underlying prompts and runs stay local to whoever ran them.
- Net for a team: shared tools + shared agent recipes + pooled performance intelligence, with a hard local boundary on anything sensitive.
Two ways this maps to your organization
The same product, two lenses
Because Invoked is local-first and config-driven, it answers both "what is this for our engineers?" and "what if we offered it to our own customers?"
Lens 1 · Internal developer DX
Your engineers building on your own APIs
An engineer turns your own services (like the API we imported live in the demo) into agent-ready tools, then builds, tests, and proves an agent against them, and ships it into your stack.
The boundary: prompts, keys, and runs never leave the engineer's laptop. A team shares the tool + agent recipes and sees pooled reliability. Nothing sensitive centralizes.
Lens 2 · White-label to your customers
An "Agent Studio" for your own end-users
Invoked is white-label by design: one config file drives the brand, the curated surfaces, and the tools. You could ship your own branded studio with your APIs pre-loaded to your customers.
The model: you become the platform vendor; each of your customers' data stays local on their own machines. You own the distribution; they keep the compliance boundary.
The whole point
Invoked is where agents are built, proven, and made observable, locally, with your keys and data never leaving the machine. No per-token toll booth. No black box. No shipping your prompts to someone else's cloud to find out if your agent works. Build it, watch it think, prove it, and ship it anywhere, with traces your stack already speaks.
Let's talk about your use case.
Team rollout, a white-label studio for your own customers, or a security review: we'll walk you through it.