Your first 30 minutes with Avery NXR

You just heard about Avery NXR. You want to try it. The question is whether the 30 minutes you'd spend testing it produces something real or just another "neat demo" you forget about by Tuesday.

The honest answer: 30 focused minutes with Avery NXR produces a real, working, shipped piece of software. Either a deployed AI agent processing a workflow you care about, or a working Next.js app generated from a prompt.

This post is the actual walkthrough. Minute by minute. What to expect, what to click, what you'll have at the end. The path that turns "I'm curious" into "I've shipped something."

What you need before you start

A laptop with at least 16GB of RAM. Mac (Apple Silicon M1 or later), Windows, or Linux all work.

About 30 minutes of focused time. Not "30 minutes between meetings while answering Slack." Actual focused time.

A specific workflow or app idea you want to test on. Vague exploration is fine; specific use cases are better.

Internet for the download. After that, everything runs locally.

That's it. No credit card. No vendor sign-up forms. No "schedule a demo with sales."

Minute 0 to 5: install

Download the Avery NXR installer from avery.software. The site detects your operating system and offers the right installer.

Run the installer. It walks through standard install steps: agreement, install location, finish.

Open Avery NXR after install completes. The first-launch flow begins.

First screen: hardware detection. Avery NXR inspects your machine. CPU, RAM, available GPU (if any). This takes about 10 seconds.

Second screen: account. You can create a free Desktop account (no credit card) or skip and use Avery NXR fully local. For a quick first test, skip is fine.

You're now in the app.

Minute 5 to 10: pick a local model

Avery NXR's model picker shows you options ranked for your hardware.

For a 16GB Mac: Qwen 2.5 Coder 7B is the typical recommendation. Strong coding-focused 7B model. Runs comfortably.

For a 32GB Mac: Qwen 2.5 Coder 14B. Better quality, fits in your memory.

For a PC with a discrete GPU: bigger options become available. The 32B or 70B models with appropriate quantization.

Pick the recommended one. Click "Use this model." Avery NXR downloads the model in the background. This takes 5-10 minutes depending on your internet speed.

While it downloads, you can explore the rest of the app. The download is non-blocking.

Minute 10 to 15: pick a starter

You have two paths from here. Pick the one that matches what you want to test.

Path A: ship your first agent

The agent path produces a working AI agent that processes a real workflow in minutes.

Click "Agents" in the sidebar. Click "+ New Agent." Choose "From template."

Templates ship pre-configured. The seven templates: Daily AI News Aggregator, Meeting Notes to Action Items, Resume Screening, Customer Support Triage, Daily Sales Pipeline Digest, Website Competitor Monitoring, Server Health Monitor.

Pick one that fits your interests. Customer Support Triage is a common choice because most teams have support volume.

The template loads in the agent builder. You see the graph: trigger, classification step, routing logic, response drafting, output. Each node is configurable.

For Customer Support Triage specifically:

• The trigger is "new email in inbox." Configure your inbox (IMAP credentials, secure local storage).
• The classification step has default categories. Edit them to match your team's actual ticket categories.
• The response drafting step has default voice. Add 2-3 examples of your team's writing style.

Save the agent. Click "Run."

The agent starts processing. The next email that arrives gets classified, routed, and a draft response generated.

You have a working AI agent five minutes into the setup.

Path B: ship your first app

The app path generates a working Next.js + Prisma application from a plain-English description.

Click "Apps" in the sidebar. Click "+ New App."

A description prompt opens. Type what you want to build. Examples:

"An expense tracker for my consulting business. Categories, monthly summaries, tax-deductible flag, CSV export."

"A reading list for the team. Title, URL, who recommended, status (todo, reading, done), brief notes."

"A simple inventory log for my Etsy shop. Item name, SKU, quantity, reorder threshold, supplier."

Be specific. The more specific the description, the better the generated app.

Avery NXR processes the description. The local model decides the archetype, decomposes the entities and features, locks a plan, and generates the code.

The generation takes 2-5 minutes for a basic app. You see a progress indicator with the steps: archetype selection, plan generation, schema generation, code generation, dependency install.

When it completes, you have a real Next.js + Prisma + Postgres app in your projects directory. The path is shown: ~/nxr-projects/[app-name].

Minute 15 to 25: customize

You have a working starter. Now customize it.

For the agent:

Open the agent builder. Tweak the prompts.

The classification prompt: add categories specific to your team. Maybe "billing", "bug report", "feature request", "general inquiry" doesn't cover what you see. Edit to match.

The response drafting prompt: add 2-3 more examples of your team's voice. Avery NXR extracts the patterns and applies them.

The routing logic: configure where high-priority tickets go (which team's inbox, which Slack channel). Add the connector if needed.

Save and re-run. The agent now processes with your customizations.

For the app:

Open the app's directory in your editor. Look at the generated code.

Notice: real Next.js 15 app structure. Real Prisma schema. Real Postgres queries. Real React components.

Make a small change. Add a field to one of the entities. Modify a UI component. Change the routing.

Tell Avery NXR what you changed via a CR (Change Request): "Add a 'priority' field to the Item model with values low/medium/high. Update the UI to display priority as a colored dot."

Avery NXR processes the CR, generates a PR to apply the change. Review the diff. Merge if it looks right.

You've now made your first AI-assisted edit to a working app.

Minute 25 to 30: run it

For the agent: it's already running. Watch the dashboard. New events flow in. Classifications happen. Drafts get generated.

For the app: run npm run dev in the app directory. The dev server starts. Open the URL it prints (typically http://localhost:3000 or http://localhost:3001).

You see your app. The pages render. You can create, edit, delete entities. The data persists in your local Postgres.

This is real, deployable software. You can push to a Git remote. Deploy to Vercel or Railway. Or keep it local.

At the 30-minute mark:

If you went the agent path: you have an AI agent running locally, processing real workflows, with full audit logging.

If you went the app path: you have a working Next.js app running locally with a real database, real CRUD operations, real authentication scaffolding if you asked for it.

Both are real. Both are yours. Both took 30 minutes.

What you have at the end

A local AI model running on your hardware. No tokens to buy. No cloud account to manage. The model runs offline.

A working piece of software that demonstrates the architecture. Either an agent processing your workflows or an app handling your data.

A working knowledge of Avery NXR's workflow. You know how to install, configure, run.

The foundation for whatever you want to build next.

This is different from most "evaluate the AI tool" experiences. You don't have a demo to look at. You have software that runs.

What comes after the first 30 minutes

The next steps depend on what you built.

If you built an agent

Customize the prompts further. The template gets you started; refinement makes it production-ready.

Add connectors. Avery NXR has 63 connectors across OAuth providers (Slack, Google, GitHub, etc.) and API-key providers (Stripe, Shopify, AWS, etc.). Wire your agent into your real tools.

Set up multiple agents. The 7 templates are starting points. Most teams end up running 5-10 agents covering different workflows.

Deploy to a shared workstation. If multiple team members will use the agents, run them on a Mac Mini or workstation accessible to the team.

If you built an app

Iterate via CRs. Write a Change Request describing the next feature. Avery NXR generates a PR. You review and merge.

Deploy to Vercel or Railway. Avery NXR's deploy panel handles the standard targets. Pick one, click Deploy, your app is live with a real URL.

Add real users. Authentication scaffolding is generated; configure it. Real users sign up, real data accumulates.

Build the second app. Now you know the workflow. The second app takes 15 minutes from prompt to running.

What to expect emotionally

The first 30 minutes are surprising for most people. The pace at which working software materializes is unusual.

A common reaction: "wait, that actually worked?" Yes. It actually worked.

Another common reaction: "but this is too simple, can it handle real things?" The simple examples are deliberately simple. The same workflow scales to complex apps and sophisticated agents. The 30 minutes is the proof of concept; the next month is real work.

A third reaction (specific to engineers): "I want to understand what it's doing under the hood." Look at the generated code. It's just Next.js + Prisma + Postgres. Nothing magical. Avery NXR generates code you'd write yourself if you had infinite time.

A fourth reaction (specific to non-engineers): "I built that?" Yes. You did. The local model did the implementation; you specified what you wanted. That's the new pattern.

What can go wrong in the first 30 minutes

Honest failure modes:

The model takes longer to download than expected. Slow internet, large model file. Be patient.

Your hardware is older than the recommended specs. The model runs but slowly. Pick a smaller model if needed.

The first agent prompt doesn't quite work. The classification is off, the routing is wrong. Iterate. The agent improves quickly with refinement.

The first generated app has an issue. Tell Avery NXR what's wrong via a CR. It iterates.

You get stuck on the connector setup. The OAuth flow takes a moment for some services. Persistence helps.

None of these are deal-breakers. Most resolve in another 5-10 minutes.

Why this matters

Most AI tooling evaluations don't produce running software in 30 minutes. They produce demos. Sandboxes. "Schedule a follow-up to see real production usage."

Avery NXR is different because the architecture is different. Local-first means the install completes and you have everything you need. No backend setup. No data migration. No deployment to validate. Just install and run.

The 30-minute promise is testable. Try it. Either you have working software at the end or you don't.

The expectation is that you do.

The deeper point

If 30 minutes produces working software, the AI tooling era has structurally changed software development.

This used to take a week (set up the framework, configure the database, write the boilerplate, debug the deployment). The week was the floor. Below the week, no real software was possible.

The week became a day with frameworks like Next.js. The day became hours with AI assistants like Cursor.

The hours becomes 30 minutes with local-first AI like Avery NXR.

The compounding effect: what used to take a year now takes a month. What used to take a quarter takes a week. The pace of building accelerates.

For founders, this means more shots on goal. For PMs, this means more validated assumptions. For engineers, this means more capacity to build the things that matter.

The first 30 minutes is just the entry point. The pattern compounds.

Get started

avery.software

Download. Install. Pick a model. Pick a starter. Customize. Run.

30 minutes. Real software. Yours to keep.