Guides

Solo developer guide

Wire up your AI pipeline, configure auto-bypass for high-confidence outputs, and close the quality loop — alone.

As a solo developer using Asenta, you are simultaneously the integrator, the reviewer, and the person who benefits from the learning loop. This guide covers the end-to-end setup: from your first API key to a pipeline that auto-fires confident items and only pulls you in for edge cases.

Setup steps

  1. 1

    Create an API key

    Go to Dashboard → Connect → API keys. Click Create key. The full key is shown once — copy it to your .env as CHECKPOINT_API_KEY. The dashboard only stores the hash.

  2. 2

    Submit AI output to /api/queue

    At the point in your pipeline where the AI has produced output, POST it to Asenta instead of acting on it directly. Include confidence if your model or scoring function provides it, and on_approve_webhook pointing at your delivery endpoint:

    bash
    curl -X POST https://yourapp.com/api/queue \
      -H "x-checkpoint-key: cpk_live_<YOUR_KEY>" \
      -H "Content-Type: application/json" \
      -d '{
        "content": "<p>Hi Alex, quick question about your Q3 roadmap...</p>",
        "confidence": 0.91,
        "segment": "outbound-email",
        "on_approve_webhook": "https://your-pipeline.com/send-email"
      }'
  3. 3

    Handle the decision webhook

    Expose a POST endpoint your server can reach, verify the HMAC signature, and act on the decision:

    webhook-handler.ts
    // Express handler — verify signature, then carry out the action
    app.post(
      "/webhooks/checkpoint",
      express.raw({ type: "application/json" }),
      (req, res) => {
        const sig = req.headers["x-checkpoint-signature"];
        const event = req.headers["x-checkpoint-event"];
    
        const expected = "sha256=" + crypto
          .createHmac("sha256", process.env.WEBHOOK_SECRET!)
          .update(req.body)
          .digest("hex");
    
        if (expected !== sig) return res.status(401).send("Bad signature");
    
        const payload = JSON.parse(req.body.toString());
    
        if (event === "on_approve") {
          // Send the email — use payload.content as the reviewed body
          await mailer.send({ to: payload.metadata.prospect, html: payload.content });
        }
    
        if (event === "on_regenerate") {
          // Produce a new version and POST it back to the SAME item, echoing the
          // regenerate_token from the payload. Do NOT create a new /api/queue item —
          // that would abandon the original and leave it stuck "regenerating".
          const fresh = await generateEmail(payload.metadata);
          await fetch(
            `https://yourapp.com/api/queue/${payload.id}/regenerated`,
            {
              method: "POST",
              headers: {
                "x-checkpoint-key": process.env.CHECKPOINT_API_KEY,
                "Content-Type": "application/json",
              },
              body: JSON.stringify({
                content: fresh,
                regenerate_token: payload.regenerate_token,
              }),
            }
          );
        }
    
        res.status(200).send("OK");
      }
    );
  4. 4

    Review items in the dashboard

    Open the Asenta dashboard queue. Click any pending item to open the review pane. The left side shows the rendered AI output; the right side is an editable WYSIWYG copy. Approve as-is, or edit and approve. Your edits are saved as preference pairs.

  5. 5

    Configure auto-bypass so low-stakes items skip review

    Go to Connect → your key → Oversight. Set a confidence threshold (e.g. 0.90) — items above it auto-fire if no always-review rule matches. Or add an auto-bypass rule: { "field": "segment", "op": "eq", "value": "internal-draft" } to let internal drafts skip review entirely.

    You can also set a manual review sample rate (e.g. 10%) — 10% of auto-bypassable items still go to review so you maintain quality visibility without reviewing everything.

  6. 6

    Close the learning loop with /api/feedback

    After a few review sessions, go to Quality in the dashboard. Promote any edit patterns you want to generalise into style rules. Then call GET /api/feedback from your generation pipeline and inject the rules into your system prompt:

    generate.ts
    // Call before generating — inject rules into your system prompt
    const res = await fetch("https://yourapp.com/api/feedback?segment=outbound-email", {
      headers: { "x-checkpoint-key": process.env.CHECKPOINT_API_KEY! },
    });
    const { style_rules, examples } = await res.json();
    
    const systemPrompt = `
    You are a B2B sales assistant. Write concise, professional outbound emails.
    
    Style rules (from reviewer edits):
    ${style_rules.map(r => "- " + r.rule_text).join("\n")}
    
    Recent edit examples (original → approved):
    ${examples.slice(0, 3).map(e =>
      `Before: ${e.original}\nAfter:  ${e.edited}`
    ).join("\n\n")}
    `.trim();

Recommended oversight config for solo use

SettingRecommendedWhy
confidence_threshold0.88–0.92Passes highly confident items; forces edge cases to review.
sample_rate0.10–0.20Reviews 10–20% of auto-bypassed items to spot drift without full coverage.
approval_timeout_minutes60–240Items expire if you forget; avoids a permanently-pending backlog.
on_timeout_actionexpireItems silently expire rather than auto-approve. Fail-safe default.
compliance_modefalseNot needed for solo use. Enable if you have a regulatory requirement.

Audit mode for testing

While developing and testing your webhook handler, enable Audit mode on the key. Every item auto-fires immediately and the webhook is called without any human intervention. Disable audit mode before going to production.

Who gets notified

When an item is queued for review, Asenta pushes a notification to the configured recipients. You control this per key (or org-wide as a default) with a notify_config under Settings. A per-key config overrides the org default. The config can target any combination of:

  • roleseveryone whose base role matches (e.g. owner, admin, approver)
  • membersspecific teammates by membership
  • groupseveryone in a named group
  • original reviewerthe person who requested the regeneration, added live when a regenerated item comes back

An empty config notifies nobody

If a key's (and the org's) notify_config is empty, no configured recipients are pushed — Asenta does not fall back to org owners/admins. Reviewers required by an attached approval policy are always notified regardless, so an item with a policy still reaches someone; an item with no policy and no config simply waits in the queue without a push. As a solo user, add yourself (by role or membership) so you get pinged.

Notifications also appear in the in-app bell, with the full history at /dashboard/notifications. Slack & Discord channels are coming to Settings.

When to add teammates

When your review queue grows faster than you can handle it, invite a colleague under Team. They get reviewer access by default — they can approve and reject items but cannot change API key settings. You stay as the admin. See the team guide for multi-reviewer approval chains.