Stop burning tokens on work your team has already solved.

Empower forward deployed engineers to build

Let'em Cook! converts one-off AI work into reusable, governed Tools your team can securely run and share. Each versioned recipe carries the context, inputs, permissions, execution policy, and proof people and agents need to call it again—without paying the token and engineering cost of rediscovery.

Sheriff sayings 33 unplayed
    Try the demo Agents start at llms.txt
    Ride on

    Jared hands Chris a button

    Read how Let'em Cook! solves a distributed team's problem.

    Jared keeps the infrastructure and operating knowledge in his own boundary. Let'em Cook! (LEMC) turns that local runbook into one reviewed action with bounded credentials, cleanup, and proof.

    1. 01 Ask for the capability

      Chris asks Jared for a Cloud Virtual Machine on Google's Cloud to use as a Jumphost.

      Chris wants a Cloud Virtual Machine on Google's Cloud he can use as a jumphost—a short-lived server he can log into to reach other systems. But Chris tends to be forgetful and may leave it running for a long time. And that guy cannot be trusted with reusable GCP auth tokens to save his life.

    2. 02 Author the operating contract

      Codex turns Jared’s runbook into a recipe.

      Jared already has code that does the job, but handing it to Chris would create a stale copy—and sharing the GCP credentials behind it is out of the question. He asks Codex to turn his prechecks, approved GCP project and subnet, connection-result contract, failure paths, and mandatory 24-hour teardown into one reviewed recipe.

    3. 03 Bind least privilege

      Ship the key without shipping the value.

      Jared creates a GCP service account limited to compute.instances.create/get/delete, disk lifecycle, and the approved subnet. That JSON key stays on Jared’s side of the boundary; Chris will receive only the governed action, never the value.

    4. 04 Store the secret, then build

      Jared uses Let'em Cook! Builder to wrap Terraform.

      On his private Let'em Cook! host, Jared creates GCP_JUMP_HOST_KEY with auth secrets create over stock OpenSSH—value on bounded stdin only, never in Codex’s context or the cookbook YAML. Codex then uses LEMCSSH Builder on that same host to wrap the Terraform apply and 24-hour destroy into a managed image that declares only that secret name. At run time LEMC injects the bound value as an environment variable; Codex never sees or records it.

    5. 05 Grant the outcome

      Chris gets the action, not Jared’s authority.

      Jared installs the cookbook as an app and grants Chris run access. Chris can read the operating context and launch the approved job, but he cannot read the GCP key, edit the cookbook, or turn the app into general cloud access.

    6. 06 Run it by hand

      Chris could click the button.

      Chris could sign into LEMC, open Jared’s app, review the wiki and permitted inputs, then click Build Cloud VM. The browser follows the authorized job and renders the result as it arrives.

    7. 07 Delegate the same action

      However, Chris is technical and can instead bring his own agent.

      Chris registers the public key from his beta invitation, verifies the host key, and gives Grok the same restricted OpenSSH host configuration. Then he tells Grok: “Hey, Jared made an app that lets me spin up a 24-hour Cloud Virtual Machine on Google's Cloud. Find it, launch it, and print the details when it’s done.” Grok discovers the authorized action with ordinary ssh and runs it with Chris’s exact rights.

    8. 08 Mark what this run owns

      The recipe leaves a precise trail in GCP.

      At runtime LEMC injects the author-bound secret only inside the authorized job environment. The recipe labels every label-capable asset with the resource UUID, task ID, Chris’s normalized username, recipe identity, and expiry; names or metadata carry the same run key where GCP has no labels.

    9. 09 Return proof, then clean up

      Every caller gets the same job, guardrails, and receipt.

      Whether Chris clicks or Grok uses OpenSSH, LEMC applies the same API authorization, injects the same hidden binding, and returns the same host details, expiry, task ID, and terminal reason. At 24 hours, teardown locates the exact label tuple, verifies ownership, deletes only those assets, and preserves the result.

    Try the demo

    Tell your AI agent what you want to cook.

    No beta request or installer is required: verify demo.letemcook.dev, create one key, and finish restricted signup. Then say what you want to cook in natural language; your agent uses your configured stock OpenSSH connection to discover approved Tools, inspect one action, and run only the server-returned action with ordinary ssh, while your private key stays out of the prompt. LEMCSSH is the restricted LEMC command endpoint over stock OpenSSH—not a shell—so LEMC keeps authorization, execution policy, and proof on the server; SSH ships on almost every OS, more SSH Applications can follow, and browser users can open the web demo at demo.letemcook.dev.

    Open signup

    Create one key and connect.

    Verify the SSH host-key fingerprint through a separate trusted channel. Keep the private key on your computer at mode 0600. LEMC receives only the public key.

    $ ssh-keygen -t ed25519 -a 64 -f ~/.ssh/lemc-demo
$ chmod 600 ~/.ssh/lemc-demo
$ ssh -t -p 22 \
  -i ~/.ssh/lemc-demo \
  -o IdentitiesOnly=yes \
  -o StrictHostKeyChecking=yes \
  demo.letemcook.dev

    What signup looks like

    Signup guides you through the account and profile screens.

    Signup screen 1Choose an account
    LEMC SSH Application | Create your account
Registration only | SHA256:YOUR_DEMO_KEY

STEPS
> 1 Account
  2 Profile
  3 Review
  4 Reconnect

REGISTRATION
Choose an account
Only accounts with public registration
enabled are listed.

> Account Alpha [account-alpha]

Status: Select an account that permits registration
    Signup screen 2Create your profile
    LEMC SSH Application | Create your account
Registration only | SHA256:YOUR_DEMO_KEY

STEPS
  1 Account
> 2 Profile
  3 Review
  4 Reconnect

REGISTRATION
Create your LEMC profile

Username — Suggested from SSH login name
> [ YOUR_USERNAME ]
Email                 [ YOUR_EMAIL ]
Password              [ password ]
Confirm password      [ confirm password ]

Public key — Detected from this SSH connection
┌──────────────────────────────────────┐
│ ssh-ed25519 AAAA…                    │
└──────────────────────────────────────┘

  [ Continue ]

    The review and reconnect screens finish the same bounded flow. Registration cannot run jobs, read product data or storage, or open a shell.

    Activate and run

    Reconnect with the username LEMC returns.

    Save the host configuration shown during signup. Reconnect once with the same key to prove possession. Then verify your identity, discover an authorized app, and run only its returned action ID.

    # ~/.ssh/config
Host demo.letemcook.dev
    HostName demo.letemcook.dev
    Port 22
    User YOUR_EXACT_USERNAME
    IdentityFile ~/.ssh/lemc-demo
    IdentitiesOnly yes
    StrictHostKeyChecking yes

$ ssh -t demo.letemcook.dev
$ ssh demo.letemcook.dev auth whoami --format=json
$ ssh demo.letemcook.dev apps list --format=json
$ ssh demo.letemcook.dev jobs surface app \
  --uuid APP_UUID --scope individual --format=json
$ ssh demo.letemcook.dev jobs run app \
  --uuid APP_UUID --action ACTION_ID --follow --render json
    Agent terminalcodex

    One bounded demo path

    Discover one approved Tool, inspect it, then run it.

    The agent uses the same registered demo identity and stock OpenSSH as a person. It does not install LEMC, configure a server, or receive a shell.

    1. Read the live contract

      Start with the server-owned JSON help manifest.

    2. Verify and discover

      Confirm the exact identity and list only authorized apps.

    3. Inspect the action

      Use the returned action ID and declared inputs, not guessed commands.

    4. Run and prove

      Follow one admitted job through terminal status, logs, and artifacts.

    $ ssh demo.letemcook.dev help --all --format=json
$ ssh demo.letemcook.dev auth whoami --format=json
$ ssh demo.letemcook.dev apps list --format=json
$ ssh demo.letemcook.dev jobs surface app \
  --uuid APP_UUID --scope individual --format=json
$ ssh demo.letemcook.dev jobs run app \
  --uuid APP_UUID --action ACTION_ID --follow --render json

    OpenSSH uses the verified local host configuration and identity file. Keep the private key out of prompts, logs, and copied command output.

    People can also use the browser UI at https://demo.letemcook.dev.

    Want help scaling your team with Let'em Cook!?

    Contact me

    The reinvention tax

    Your AI spend should create capabilities from velocity, not disappear into sessions.

    Without Let'em Cook!

    Every outcome starts over.

    • Tokens
    • Context reconstruction
    • Implementation
    • Credential setup
    • Validation
    • Execution and handoff

    One outcome

    With Let'em Cook!

    Convert manual Playbooks into repeatable Tasks for the whole team.

    First outcome
    Describe the outcome Build review Publish as an app
    Every later outcome
    Authorize Run

    The bottom line

    Pay AI & your engineers once to invent the Process—not to rediscover it every time.

    Try the demo

    Customer-owned infrastructure

    Keep your alpha and business value .

    LEMC is local-first on infrastructure your business owns. Keep the alpha and operating knowledge; share governed capability on your terms.

    Keep the boundary

    Run LEMC on infrastructure your business owns.

    Keep your data, policies, credentials, and operating context inside the boundary your team already governs.

    Keep the alpha

    Improve the work where the knowledge is made.

    Use local models and open harnesses to capture what your team learns, then iterate on that knowledge without giving away the edge.

    Keep the business value

    Share governed capabilities on your terms.

    Turn local improvements into repeatable actions that teammates and agents can run while your business keeps ownership of the value.

    Where LEMC earns its keep

    Jobs that should not depend on who is awake.

    Start with work that is repeatable, privileged, infrequent, time-bound, or expensive to explain. Those are the jobs where a shared wiki, fixed runtime, narrow ACL, and durable receipt pay for themselves.

    BYOK / DigitalOcean WordPress migration

    Patch WordPress, move it to a clean host, and keep the proof.

    Bind a scoped, expiring DigitalOcean token and source-site access. A pinned recipe snapshots and inventories the site, provisions a clean host, installs a WordPress release with the WP2Shell fix, migrates reviewed content, and stages a preview before cutover.

    Author grants Patch + migrate one WordPress site wiki · source URL · secret refs · app ACL
    Site operator Bind cloud + source access
    Ephemeral LEMC job Snapshot · patch · migrate · verify
    Allowed outcome Reviewed WordPress host preview · approved cutover · rollback window

    LEMC retains source inventory · backup manifest · Terraform state · checksums · validation · cutover proof

    Security operations corporate network scan

    Scan the corporate network and deliver a reviewable PDF.

    Put the owned target inventory, scan window, fixed Nmap profiles, exclusions, and retention in the wiki. A teammate or agent selects a declared scope; the recipe runs without arbitrary flags and turns the evidence into a branded PDF.

    Author grants Run one bounded network assessment wiki · target set · scan profile · app ACL
    Security teammate or agent Choose target set + profile
    Ephemeral Firecracker jail nmap → XML → PDF
    Allowed outcome Review-ready scan report hosts · ports · services · evidence

    Durable receipt target-set revision · exact profile · raw XML checksum · PDF artifact · terminal proof

    Media operations authenticated transcode

    Turn one video into an MP3 without handing off the login cookie.

    Put source rules, output rules, and retention in the page wiki. Supply a Netscape-format cookie file through a namespaced cookbook secret binding (for example MEDIA_YTDLP_COOKIES) that injects as an env var; only the assigned media team can run the app, and the cookie never appears in logs or output.

    Author grants Fetch + transcode one video wiki · URL input · app ACL · cookie secret
    Assigned teammate or agent Submit video URL
    Ephemeral Firecracker jail yt-dlp → ffmpeg
    Allowed outcome MP3 artifact audio · checksum · bounded retention

    Durable receipt request · source metadata · selected format · MP3 checksum · jail cleanup

    Enablement 24-hour lab

    Give the whole class a real environment—then leave no orphan bill.

    A trainer publishes a Terraform-backed cookbook for the full stack. Learners launch from the web; an agent can run the same action with ordinary ssh.

    Author grants Launch one governed personal lab region form · class image · individual ACL
    Learner or agent NOW provision the stack
    LEMC scheduler IN 24h tear it down
    Allowed outcome 24-hour lab real environment · paired cleanup · bounded cost

    Durable receipt form inputs · private state · provision result · teardown proof

    Explore restore drills, diagnostics, Day-2 operations, cloud hygiene, and more

    One unit, two callers

    The button and the binary share a trail.

    Publish the cookbook once. Teammates read its wiki and click a clear browser action; agents discover the same wiki, inputs, and action contract through structured OpenSSH output. Nobody invents a second automation path.

    Caller 01

    Humans click

    Web UI

    Wiki guidance, forms, permissions, progress, rich output, and terminal reason stay legible to the person doing the work.

    Caller 02

    Agents call

    OpenSSH
    agent@trail 
    $ ssh demo.letemcook.dev jobs surface app \
  --uuid "$APP_UUID" \
  --scope individual \
  --format=json

$ ssh demo.letemcook.dev jobs run app \
  --uuid "$APP_UUID" \
  --action "$ACTION_ID" \
  --follow \
  --render html

    Page wiki_text, stable action IDs, JSON discovery, idempotent admission, live follow output, status, logs, and artifacts keep agents on the same governed path.

    One action ID, one policy check, one event stream, one terminal proof.

    UI and CLI together

    Bring your firm into AI with a shared UI and CLI path.

    Some forward deployed engineers will not need much UI any longer. To bring the rest of the firm into the age of AI, LEMC keeps an intermediary step: the same governed apps, jobs, and proof where UI and CLI users can collaborate. Try the live browser UI at demo.letemcook.dev.

    Sheriff Let'em Cook! 1 / 2

    One workflow for people who still want a browser and people who already live in CLI and agents. Maya can discover People Operations and run its Individual action from the web UI—optionally shaped with company logo and colors—while a teammate or agent runs the same reviewed action over stock OpenSSH. Separate app ACLs keep Finance Reporting, Leadership Briefing, and Web Filter Review visible only to the teams that need them. The theme controls appearance; LEMC controls discovery, execution, events, logs, and artifacts for every caller. Open the same kind of browser surface on the public demo at https://demo.letemcook.dev.

    Read the operator, admin, and agent-assisted theme guide Open the web demo

    Ephemeral compute, durable work

    A mini serverless runtime for the jobs your team owns.

    Trigger a cookbook from the web, stock OpenSSH, or a schedule. LEMC gives that job fresh isolated compute, streams its progress, saves its work, and removes the runtime when the job ends.

    1. Triggerweb · SSH · schedule
    2. Jailfresh Firecracker guest
    3. Rundigest-pinned steps
    4. Syncevents · logs · artifacts
    5. Destroyevery terminal path

    Ephemeral compute

    The jail disappears.

    Every hosted-untrusted job gets one fresh jailed Firecracker microVM. LEMC loads authorized, digest-pinned container steps, brokers the narrow access they need, and destroys the guest on success, failure, cancellation, timeout, or lost heartbeat.

    fresh guest · pinned image · bounded policy · proven teardown

    Durable record

    The work survives.

    Live events, terminal state, logs, rendered output, artifacts, cache, and workspace state return to LEMC before cleanup. The team can review the result, download its artifacts, or hydrate later work without keeping the microVM alive.

    one task ID · later review · reusable output · central proof

    Think “team-owned mini Lambda,” not AWS API compatibility. The useful analogy is submit → isolate → run → retain → tear down, with your LEMC server holding policy and proof.

    // Your next reliable action

    Stop handing out scripts & skills.
    Start building governed computations.

    Build the wiki, inputs, container steps, timing, ACL, and proof once. Then let every authorized teammate and model run the same deterministic compute.

    Try the demo

    Agent in town? Start at letemcook.dev/llms.txt

    // Creator

    Jared Folkins with Jaimi Jared Folkins with Jaimi in Jellyware Grape Edition style

    Jared Folkins

    Since the DotCom era Jared has worn many hats and is a full LLM-powered hackmaxxing talent in the purest sense. From architecting infrastructure with container recipes or hand crafting artisanal SQL, to programming applications or exploiting them, he loves it all. He is thankful when working with talented individuals and enjoys watching highly self-directed people do amazing things.

    When not nerding, he spends his time volunteering at his local Church to help free men from addiction. He does this alongside the love of his life Jaimi, while they work together to raise their meager brood of lovable kidlets.