Your first build

// app/api/summarize/route.ts
import { ai } from "@wacht/backend";

export async function POST(req: Request) {
  const { userId, notesText } = await req.json();

  // Look up or create the actor for this user
  const { actor } = await ai.lookupActor({
    subject_type: "user",
    external_key: userId,
  });
  const actorId =
    actor?.id ??
    (await ai.createActor({
      subject_type: "user",
      external_key: userId,
    })).id;

  // Create (or reuse) a project pairing this actor with the agent
  const project = await ai.createActorProjectFlat(
    { actor_id: actorId },
    { agent_id: "agent_id_from_console", name: "Notes" }
  );

  // Create a task on that project
  const task = await ai.createProjectTaskBoardItem(project.id, {
    title: "Summarize these notes",
    description: notesText,
  });

  return Response.json({ projectId: project.id, taskId: task.id });
}

// instrumentation.ts (or wherever your server boots)
import { initBackend } from "@wacht/backend";

initBackend({ secretKey: process.env.WACHT_BACKEND_SECRET! });

// In your Axum/Actix handler
use wacht::{try_get_client, models::{LookupActorParams, CreateActorRequest, CreateActorProjectRequest, CreateProjectTaskBoardItemRequest}};

pub async fn summarize(Json(body): Json<SummarizeRequest>) -> Result<Json<TaskRef>, AppError> {
    let client = try_get_client()?;

    let lookup = client
        .ai()
        .actors()
        .lookup_actor(LookupActorParams {
            subject_type: "user".into(),
            external_key: body.user_id.clone(),
        })
        .send()
        .await?;

    let actor_id = match lookup.actor {
        Some(a) => a.id,
        None => {
            client
                .ai()
                .actors()
                .create_actor(CreateActorRequest {
                    subject_type: "user".into(),
                    external_key: body.user_id,
                })
                .send()
                .await?
                .id
        }
    };

    let project = client
        .ai()
        .actor_projects()
        .create_actor_project(
            actor_id,
            CreateActorProjectRequest {
                name: "Notes".into(),
                agent_id: Some("agent_id_from_console".into()),
                ..Default::default()
            },
        )
        .send()
        .await?;

    let task = client
        .ai()
        .actor_projects()
        .create_board_item(
            project.id.clone(),
            CreateProjectTaskBoardItemRequest {
                title: "Summarize these notes".into(),
                description: Some(body.notes_text),
                ..Default::default()
            },
        )
        .send()
        .await?;

    Ok(Json(TaskRef { project_id: project.id, task_id: task.id }))
}

use wacht::init_from_env;

#[tokio::main]
async fn main() {
    init_from_env().await.expect("wacht init failed");
    // build your router...
}

// app/api/task/[taskId]/file/route.ts
import { ai } from "@wacht/backend";

export async function GET(req: Request, { params }) {
  const url = new URL(req.url);
  const path = url.searchParams.get("path")!;
  const file = await ai.downloadProjectTaskBoardItemFilesystemFile(
    params.taskId,
    { path },
  );
  return new Response(file.body, {
    headers: { "content-type": file.contentType },
  });
}

pub async fn download_task_file(
    Path((project_id, task_id)): Path<(String, String)>,
    Query(q): Query<FileQuery>,
) -> Result<Response, AppError> {
    let client = wacht::try_get_client()?;
    let file = client
        .ai()
        .actor_projects()
        .download_board_item_filesystem_file(project_id, task_id, q.path)
        .send()
        .await?;
    Ok(Response::builder()
        .header(
            "content-type",
            file.content_type.unwrap_or_else(|| "application/octet-stream".into()),
        )
        .body(file.body.into())
        .unwrap())
}