# Neolit — product documentation Machine-readable copy of . Both are built from the same source, so this file and that page cannot disagree. - **Product:** Neolit — you hire AI employees, give them outcomes instead of prompts, and get back work you can inspect together with the evidence that it happened. - **Article address:** `https://neolit.ai/docs#
/
` — stable, bookmarkable, and quoted by support. Every heading below carries its own. - **Language:** English is the source of the product; the page itself is translated where a locale file exists, this export is not. - **Currency:** everything an owner spends is shown in tokens (◆). Dollars appear only on token packs and on money an owner’s own customers pay them. - **Short index of the public site:** ## Contents - **Start here** — What the platform is and how work gets done - [What Neolit is](https://neolit.ai/docs#start/what-is-neolit) — `start/what-is-neolit` - [Core concepts](https://neolit.ai/docs#start/concepts) — `start/concepts` - [Hiring your first employee](https://neolit.ai/docs#start/first-hire) — `start/first-hire` - [How work actually happens](https://neolit.ai/docs#start/how-work-happens) — `start/how-work-happens` - **AI employees** — Anatomy, hiring, the dashboard, tools, memory, limits - [Anatomy of an employee](https://neolit.ai/docs#agents/anatomy) — `agents/anatomy` - [The marketplace](https://neolit.ai/docs#agents/marketplace) — `agents/marketplace` - [Creating your own employee](https://neolit.ai/docs#agents/create-own) — `agents/create-own` - [The employee dashboard](https://neolit.ai/docs#agents/dashboard) — `agents/dashboard` - [Chat: reading a turn](https://neolit.ai/docs#agents/chat) — `agents/chat` - [What an employee can do](https://neolit.ai/docs#agents/capabilities) — `agents/capabilities` - [Tool reference](https://neolit.ai/docs#agents/tools-reference) — `agents/tools-reference` - [Skills and playbooks](https://neolit.ai/docs#agents/skills) — `agents/skills` - [Scheduled and recurring work](https://neolit.ai/docs#agents/schedules) — `agents/schedules` - [Sites your employee publishes](https://neolit.ai/docs#agents/sites) — `agents/sites` - [What "done" means](https://neolit.ai/docs#agents/acceptance) — `agents/acceptance` - [Phone and voice](https://neolit.ai/docs#agents/voice) — `agents/voice` - [The browser and sign-ins](https://neolit.ai/docs#agents/browser) — `agents/browser` - [Channels](https://neolit.ai/docs#agents/channels) — `agents/channels` - [What an employee remembers](https://neolit.ai/docs#agents/memory) — `agents/memory` - [Guardrails, approvals and limits](https://neolit.ai/docs#agents/guardrails) — `agents/guardrails` - [Artifacts](https://neolit.ai/docs#agents/artifacts) — `agents/artifacts` - [Removing an employee](https://neolit.ai/docs#agents/delete) — `agents/delete` - **Goals** — The autonomous half of the product - [What a goal is](https://neolit.ai/docs#goals/what-is-goal) — `goals/what-is-goal` - [Goal modes](https://neolit.ai/docs#goals/modes) — `goals/modes` - [Start with AI](https://neolit.ai/docs#goals/start-with-ai) — `goals/start-with-ai` - [The goal cycle](https://neolit.ai/docs#goals/cycle) — `goals/cycle` - [Evidence and the outcome verdict](https://neolit.ai/docs#goals/evidence) — `goals/evidence` - [Accepting a result](https://neolit.ai/docs#goals/review) — `goals/review` - ["Fix this": revisions and follow-ups](https://neolit.ai/docs#goals/revise) — `goals/revise` - [When a goal stops](https://neolit.ai/docs#goals/stalled) — `goals/stalled` - [Budget and spend](https://neolit.ai/docs#goals/budget) — `goals/budget` - [Outreach goals](https://neolit.ai/docs#goals/outreach) — `goals/outreach` - **Teams** — Several employees, one group chat, one orchestrator - [What a team is](https://neolit.ai/docs#teams/what-is-team) — `teams/what-is-team` - [Building a team](https://neolit.ai/docs#teams/build-team) — `teams/build-team` - [Team chat and handoffs](https://neolit.ai/docs#teams/team-chat) — `teams/team-chat` - [The board and delegation](https://neolit.ai/docs#teams/team-board) — `teams/team-board` - [Review, loops and what a team learns](https://neolit.ai/docs#teams/team-learning) — `teams/team-learning` - [Team rules and limits](https://neolit.ai/docs#teams/team-limits) — `teams/team-limits` - **Projects** — A container for a business: market, strategy, work, metrics - [What a project is](https://neolit.ai/docs#projects/what-is-project) — `projects/what-is-project` - [Creating a project](https://neolit.ai/docs#projects/intake) — `projects/intake` - [Market, languages and currency](https://neolit.ai/docs#projects/market) — `projects/market` - [Channels and the cost of entry](https://neolit.ai/docs#projects/project-channels) — `projects/project-channels` - [What members see every turn](https://neolit.ai/docs#projects/context) — `projects/context` - [Knowledge Hub](https://neolit.ai/docs#projects/knowledge) — `projects/knowledge` - [Strategy and decisions](https://neolit.ai/docs#projects/strategy) — `projects/strategy` - [Goals, stages and staffing](https://neolit.ai/docs#projects/work) — `projects/work` - [Autopilot](https://neolit.ai/docs#projects/autopilot) — `projects/autopilot` - [Feed and what needs you](https://neolit.ai/docs#projects/feed) — `projects/feed` - [Metrics and revenue](https://neolit.ai/docs#projects/metrics) — `projects/metrics` - [Enquiries, clients and site records](https://neolit.ai/docs#projects/admin) — `projects/admin` - [The public project page](https://neolit.ai/docs#projects/public) — `projects/public` - [Project settings](https://neolit.ai/docs#projects/project-settings) — `projects/project-settings` - **NEO** — The orchestrator window - [What NEO is](https://neolit.ai/docs#neo/what-is-neo) — `neo/what-is-neo` - [Doors, the badge and decisions](https://neolit.ai/docs#neo/neo-doors) — `neo/neo-doors` - [Running work from NEO](https://neolit.ai/docs#neo/neo-run) — `neo/neo-run` - **The platform** — The stack underneath: models, browsers, connectors, apps - [What Neolit runs on](https://neolit.ai/docs#platform/stack) — `platform/stack` - [Models, and how one is chosen](https://neolit.ai/docs#platform/models) — `platform/models` - [Apps, connectors and your own keys](https://neolit.ai/docs#platform/integrations) — `platform/integrations` - [The API catalogue](https://neolit.ai/docs#platform/catalog) — `platform/catalog` - [The Mac app](https://neolit.ai/docs#platform/mac) — `platform/mac` - [Programmatic access](https://neolit.ai/docs#platform/access) — `platform/access` - **Money and plans** — Tokens, billing, and getting paid by your own customers - [Tokens (◆)](https://neolit.ai/docs#money/tokens) — `money/tokens` - [Plans and billing](https://neolit.ai/docs#money/plans) — `money/plans` - [Getting paid by your customers](https://neolit.ai/docs#money/owner-payments) — `money/owner-payments` - **Trust and safety** — Access, provenance, and what we refuse to fake - [Sessions, access and permissions](https://neolit.ai/docs#trust/permissions) — `trust/permissions` - [Provenance: measured, reported, invisible](https://neolit.ai/docs#trust/provenance) — `trust/provenance` - [What we refuse to fake](https://neolit.ai/docs#trust/honesty) — `trust/honesty` - [Where your data lives](https://neolit.ai/docs#trust/data) — `trust/data` - [Interface languages](https://neolit.ai/docs#trust/languages) — `trust/languages` - **Reference** — Addresses, statuses, limits, and honest gaps - [Address map](https://neolit.ai/docs#reference/urls) — `reference/urls` - [Statuses and stop reasons](https://neolit.ai/docs#reference/statuses) — `reference/statuses` - [Limits and caps](https://neolit.ai/docs#reference/limits) — `reference/limits` - [Common questions](https://neolit.ai/docs#reference/faq) — `reference/faq` - [Known limitations](https://neolit.ai/docs#reference/not-yet) — `reference/not-yet` --- # Start here _What the platform is and how work gets done_ ## What Neolit is `start/what-is-neolit` · https://neolit.ai/docs#start/what-is-neolit **Neolit is a place where you hire AI employees, give them outcomes instead of prompts, and get back work you can inspect — files, published pages, sent emails, updated records — together with the evidence that the work happened.** A chatbot answers. An AI employee is accountable: it holds a goal across days, uses your approved accounts and tools, stops when it hits a wall, names the wall, and hands you a result you can accept or send back for revision. Everything it spends is metered, everything it does is logged, and you can stop it at any second. #### Three containers of work Everything in Neolit lives inside one of three containers. They are not interchangeable, and picking the right one is the single most useful decision you make at the start. - **Employee (agent)** — One worker with one job. Own chat, own memory, own goals, own channels, own dashboard at /dashboard/. Start here if you have a single repeating job — answer reviews, qualify leads, publish listings. - **Team** — Several employees under one label, with a shared group chat and an orchestrator that routes work between them. Each member keeps a private dashboard. Use a team when one job needs several crafts — a strategist, a copywriter, an ops person. - **Project** — A container for a business, not for a worker. It has a market, a strategy, shared memory, materials, a task board, an event feed, metrics, its own contacts, and its own goals. Members (employees and whole teams) join it and receive the project context in every turn they take. Use a project when the thing you want is an outcome for a business, not a task for a person. #### The unit of work is a goal You do not brief an employee task by task. You give it a goal — a stated outcome, optionally a number to reach and a cadence — and the platform turns that into runs. A run plans, acts, verifies what actually changed, and reports. The goal ends when there is proof, when you stop it, or when it hits a wall it cannot pass; in every one of those cases it tells you which one happened and why. > **Note:** Everything you spend is shown in tokens (◆). Dollars appear in exactly two places: the price of a token pack, and money your own customers pay you. If you see a cost in Neolit, it is a ◆ number. #### What the platform guarantees - Authority is granted, never assumed. An employee has no access to any account until you connect it, and no permission you did not switch on. - Work is observable. Every tool call becomes a step row in the chat, every file lands on a shelf, every goal keeps a per-goal activity log. - A result is separate from a report about a result. A goal cannot close as "reached" without a trace — a file, a confirmed effect, or a live number that moved. - Stopping is instant and always available: pause, stop, archive a goal; stop a running turn; delete an employee. #### Where to read next - **You want to start today** — Core concepts, then Hiring your first employee. - **You want to know what it can actually do** — What an employee can do, then the Tool reference and What "done" means. - **You want to hand over an outcome, not a task** — The whole Goals section, starting with What a goal is. - **You are running a business through it** — The Projects section — market, strategy, work, metrics. - **You want to know what is underneath** — The platform: the stack, the models, the connectors. - **You want to know what it does badly** — Known limitations, and What we refuse to fake. ## Core concepts `start/concepts` · https://neolit.ai/docs#start/concepts **The vocabulary the whole product uses. If a screen says one of these words, it means exactly this.** - **Listing** — A public employee on the marketplace. It has a role, a knowledge base, skills, and a price. A listing is a template, not your worker. - **Hire / clone** — Hiring copies a listing into your workspace as your own employee. Your copy has its own chat, memory, goals and settings; nothing you do to it touches the listing or anybody else who hired it. - **Employee (agent)** — Your worker. Identified by a slug derived from its name; that slug is its dashboard URL and its @handle. Renaming is a real operation, not a label change. - **Turn** — One complete reply cycle. The employee reads its context, calls tools in a loop, and produces a reply. A turn can call many tools; each one appears in the chat as a step. - **Tool** — A concrete capability — search the web, drive a browser, write a file, send an email, publish a site, read your contacts. Tools are gated: by the employee role, by your permissions, and by the phase of the goal. - **Goal** — A stated outcome with a mode, a budget, and a definition of done. Goals are the autonomous half of the product: they run without you in the chat. - **Run** — One cycle of a goal — plan, act, verify, report. A goal usually takes several runs. Every run has its own cost, its own log, and its own artifacts. - **Artifact** — Something you can hold: a document, spreadsheet, image, video, deck, or a published site. Artifacts land on the Artifacts shelf and in the goal feed. - **Evidence** — The observable trace that a piece of work happened — a page that now contains the text, a message with a delivery confirmation, a metric point that moved. Evidence is what turns "the agent said it did it" into "it happened". - **Token (◆)** — The unit of spend. Everything the platform charges you for is denominated in ◆. - **Wallet** — Your actual spending balance. A plan is a display layer over it; the wallet is what the gate reads before any paid action. - **Workspace** — The memory boundary. A solo employee works in its own workspace; a project member works in the project workspace. This is why a project member sees project notes, tables and contacts, and a solo employee does not. - **NEO** — The orchestrator — a floating window on every page that gives you one place to answer open decisions, launch work, and talk across your whole workspace. > **Tip:** Two words that look alike but are not: a task is a line on a board, a goal is an outcome the platform will pursue on its own. Boards are for you and for coordination; goals are what make the employee work when you are asleep. ## Hiring your first employee `start/first-hire` · https://neolit.ai/docs#start/first-hire **From an empty account to a worker with a running goal, in the order the product actually works.** 1. Create an account. New accounts start on the Free plan with a welcome balance, so you can run real work before paying anything. 2. Open the marketplace at /Employees. Every card is a role: a marketplace operator, a review responder, an SDR, an order desk, a local-platform specialist. Filter by what you actually need done this week, not by what sounds impressive. 3. Open a profile at /agent/. The profile is built from that role: what it does, what it knows, which systems it touches, what a typical run looks like. 4. Hire. You land on the onboarding page, sign up if you have not yet, and the copy is created in your workspace. You are redirected to its dashboard. 5. Say hello in Chat. The first turn is worth doing by hand — it tells you how the employee talks, what it already knows about your business, and what it will ask for. 6. Connect what it needs. If it must send email, connect a mailbox; if it must post somewhere, connect that channel or sign it in through the browser. Nothing is connected by default. 7. Set one goal. Not five. Use "Start with AI" if you would rather answer two or three questions than write a definition of done yourself. > **Tip:** Give the first goal a small, checkable outcome — "publish a one-page site for X and put the enquiry form on it", not "grow the business". You are calibrating trust, and a small outcome produces evidence fast. #### What happens next without you Once a goal is active, the platform schedules runs on its own. Each run appears in the goal activity log and is mirrored into the employee chat: it took the goal, it is working, here is the result. When a run produces something you should decide on, the decision reaches you in three places at once — the goal card, the chat, and the NEO window — and answering it in any one of them closes it everywhere. ## How work actually happens `start/how-work-happens` · https://neolit.ai/docs#start/how-work-happens **The mechanics of a single turn. Understanding this explains almost every behaviour you will see later — why an employee asks before acting, why it sometimes says it cannot, and why a result carries proof.** #### A turn, step by step 1. The employee is assembled: its role prompt, its knowledge base, your operator memory, an inventory of its notes, tables and scheduled tasks, the running summary of your conversation, and the live state of its browser. 2. It calls the model, which either answers or asks for a tool. 3. The tool call passes the gates: is this tool part of this employee role, did you permit it, is the goal in a phase where writing is allowed, is the content it is acting on trusted. 4. The tool runs. Its result goes back into the loop, and a step row goes to your screen immediately — you watch the work, not a spinner. 5. The loop repeats until the employee has an answer, up to a hard cap per turn. 6. The turn is reflected into memory, and the spend is settled. #### Why it verifies instead of asserting Every state-changing action in a browser is read back: after clicking send, the platform re-reads the live page and asks a narrow question — did this actually go through, is there an unsent draft still open, is there a confirmation or an error. A run that cannot see a confirmation marks the step unverified rather than successful. That is why a goal will sometimes tell you "posted, not confirmed" instead of claiming a win. #### Why it sometimes refuses Before a goal starts, the platform checks whether the outcome is reachable with the capabilities that actually exist. If it is not — for example a goal that requires running a live backend service — the goal does not burn your balance discovering that. It stops with a named reason and, where possible, proposes the nearest reachable version of the same outcome. > **Warning:** A refusal that names its reason is a feature. The failure mode we design against is the opposite: an agent that spends your balance for an hour and reports a success it cannot show you. --- # AI employees _Anatomy, hiring, the dashboard, tools, memory, limits_ ## Anatomy of an employee `agents/anatomy` · https://neolit.ai/docs#agents/anatomy **What an employee is made of, and which parts you control.** - **Identity** — Name, avatar, role. The name generates the slug used in the dashboard URL and as the @handle in team chat, so it is an identifier rather than a caption. - **Knowledge base** — The employee-specific reference — how its platform works, what good output looks like, the rules of its craft. It is loaded in full on every turn and is treated as data, never as instructions. - **Reference links** — URLs you attach. The platform crawls them, caches the text, and refreshes that cache periodically. Cached pages are marked as possibly stale, so the employee knows to re-read when a detail matters. - **Skills** — Named procedures the employee can load on demand. The prompt carries only their names and descriptions; the content is fetched when a skill is actually needed, so skills cost nothing until used. - **Tools** — The capability set. Some are always on (memory, notes, tables, your contacts, self-configuration), the rest depend on the role. - **Memory** — Three layers: what it learned about you, what it learned about the work, and the running summary of your conversation. See "What an employee remembers". - **Work profile** — How it behaves — tone, boundaries, house rules, working hours. Editable in Settings and by asking in chat. - **Guardrails** — What it may do without asking, what needs approval, and what is forbidden. > **Warning:** Renaming an employee changes its dashboard URL and its @handle. Do it early or not at all; bookmarks and team mentions follow the name. ## The marketplace `agents/marketplace` · https://neolit.ai/docs#agents/marketplace **Where employees come from, how they are ordered, and what "ready to hire" means.** The marketplace at /Employees is a roster of public listings — role-specific workers built around a platform or a craft: marketplace sellers, review and reputation, ads operations, social and messenger presence, local service platforms, sales development, order desks, research. Each listing has a public profile at /agent/ and a hire page at /hire/, both of which are real, crawlable pages rather than an app view. #### What makes a listing hireable A listing can be hired when it has a knowledge base. That single condition is checked identically by the storefront and by the server, so the button you see and the answer you get always agree: the storefront cannot offer you someone the backend would refuse, and it cannot mark as "coming soon" someone the backend would happily clone. #### Order and size of the storefront - The storefront is capped for weight, and the response says so: it carries the total, a truncation flag, and the display limit, so nothing is silently hidden. - Public profile pages and the sitemap are built from the full catalogue, not from the capped storefront — search engines see every listing. - Ordering is deterministic: ready listings first, then role popularity, then installs, then slug. It is not "most recently updated", and the "runs" number on a card is a stable decorative value, not telemetry. #### What hiring copies Hiring creates your own employee from the listing: role, knowledge base, skills, example tasks and avatar come across. From that moment the two have nothing in common — your copy has its own chat, memory, goals, channels and settings, and the same listing can be hired again into a different team without collision. > **Note:** Beyond the marketplace roster there are playbook catalogues — role packs grouped by division (agency, GTM, marketing, product, research, C-suite and more). They are used both as storefront tabs and as the pool a project goal draws from when it needs to staff itself. ## Creating your own employee `agents/create-own` · https://neolit.ai/docs#agents/create-own **When no listing fits, describe the job and the platform builds the worker.** From /create you can create an employee, a team, or a project. For an employee you write a brief — what the job is, what the business is, what good looks like. The server derives the role, generates the knowledge base, picks the skill set, crawls the reference material you gave it, and returns a worker with a dashboard. - The request is synchronous and takes minutes, not seconds — the screen shows the real stages rather than a spinner. Do not close it. - Inside a team, the same door exists as "Create employee": the new worker inherits the team settings and joins the group chat with a note. - Inside a project, a created employee is briefed with the project context, so it starts knowing the market, the strategy and the current focus. > **Tip:** A good brief names the outcome and the constraints, not the steps. "Handle order enquiries from our Instagram DMs, answer in Portuguese, never quote a price above the list" produces a far better worker than a list of instructions. ## The employee dashboard `agents/dashboard` · https://neolit.ai/docs#agents/dashboard **Everything about one worker lives at /dashboard/. Here is what each tab is for.** - **Overview** — Goals. The list of active goals, the composer for a new one, and the detail view of the goal you opened — its plan, its runs, its evidence, its decisions. The open goal and the open tab both survive a page reload. - **Chat** — The live conversation. Also where the employee brings results, asks for approval, and shows cards you can act on. - **Tasks** — The board — items you or the employee put there. Useful for coordination; not the same thing as a goal. - **Metrics** — Two blocks: real performance numbers from actual runs and spend, and the platform KPIs that this role declares it works towards. The second block declares what is measured, it does not invent telemetry. - **Browser** — The live browser: what page the employee is on, what it is doing, and the session state. You can watch a run happen. - **Inbox** — Mail the employee received on its own address. - **Contacts** — Your CRM — people, companies, handles on platforms. Importable from CSV, readable by the employee as a tool. - **Calendar** — Scheduling and busy state. - **Memory** — What it knows about you and about the work, as editable documents. - **Calls** — Voice call history and recordings. - **Guardrails** — Permissions, approval rules, spending limits. - **Apps** — Connected accounts and integrations, plus sites reachable through an API. - **Billing** — Balance, plan, spend history. - **Audit** — The log of what was actually executed. - **Settings** — Identity, knowledge, behaviour, channels, domain, and deletion. > **Note:** A team member opens the same dashboard. Clicking a member from a team opens that member’s own canonical dashboard with all personal tabs; the team chat is one tab of the shared shell, not a separate app. ## Chat: reading a turn `agents/chat` · https://neolit.ai/docs#agents/chat **The chat is not a transcript, it is an instrument panel. Every kind of row means something specific.** #### Row types - **Message** — Plain text from you or the employee. Links are rendered safely; a raw URL is never shown where a title exists. - **Step** — A tool in flight. It names the concrete action — the file being written, the page being opened, the table being updated — and turns into a completed row when the tool returns. - **Artifact card** — A produced file, site, image or video, with actions: open, rename, revise, delete. - **Approval** — A request for permission before an irreversible action. Answer it in place. - **Alert / event** — Something that happened outside the chat and concerns you. - **Report** — A structured result with its sources. Each source shows its site icon and title; you can click through. - **Spend** — A compact ◆ line for what the turn cost. - **Decision card** — A goal result waiting for accept or revise, attached under the message that produced it. #### Behaviour worth knowing - Replies arrive over a live stream. If you reload mid-turn, the message you sent is already there and the answer arrives when it is ready. - A running step is replaced in place by its finished form — you will not see the same action twice. - History loads upward as you scroll, without the scroll jumping. - Stop halts a running turn on the server, not just in your browser. - Machine markers the runtime uses internally are hidden from you deliberately. > **Tip:** If you want a file changed, say so under the file — either in chat or with the revise action on the artifact. That routes the note to the exact piece of work instead of starting a new conversation about it. ## What an employee can do `agents/capabilities` · https://neolit.ai/docs#agents/capabilities **The capability surface, grouped by what you would actually ask for.** | Area | What it can do | | --- | --- | | Web | Search, open and read pages, follow links, fetch APIs. Reading returns a pagination hint so a long list is not silently truncated, and reports honestly when a page is a canvas or a virtual list it could only partly see. | | Browser | Drive a real Chromium session: click, type, select, drag, scroll, paginate, upload, download, screenshot. Sessions and logins persist between runs. | | Documents | Write and edit documents, commercial proposals, reports and spreadsheets, and export them as PDF. | | Presentations | Build a deck from a brief and render it to a file. | | Sites | Generate and publish a site, wire its forms to your project, attach your own domain, and instrument it for traffic metrics. | | Images and video | Generate images; generate video up to a minute — longer clips are shot in segments and joined into one file rather than silently truncated. | | Email | Send and receive on the employee’s own address, or through your connected mailbox. Sequences with follow-ups are supported and rate-limited. | | Voice | Take and place phone calls with a live realtime loop, plus post-call notes. | | Messengers and social | Operate Telegram, WhatsApp, Slack and Discord, and work social platforms through the browser. | | Records | Read and write your tables, notes and contacts; import a CSV of contacts; keep working data where you can see it. | | Scheduling | Create scheduled tasks and recurring work, and manage a calendar. | | Money in | Create payment links against your own merchant account and connect that account, so your customers pay you directly. | | Code | Execute code for data work and transformations. | | Self-configuration | Update its own knowledge, notes, house rules and enabled tools — within the guardrails you set. | > **Warning:** A capability is not the same as an integration. "Can operate Telegram" means the employee can do the work; it still needs you to connect the account or sign it in first. #### What is deliberately absent - It does not run your advertising accounts. It will build the page, write the copy, define the segments, tag the links and receive the enquiries — the ad account stays yours. - It does not deploy or operate live backend services. Goals that need one are rewritten into the nearest reachable form: a published page plus a project table. - It does not hold your money. Payments from your customers go to your own merchant account. ## Tool reference `agents/tools-reference` · https://neolit.ai/docs#agents/tools-reference **The actual tools an employee calls, by family. When a step row in your chat names one of these, this is what it did.** The registry holds roughly a hundred and fifty tools. Which ones a given employee has depends on three things: its role, the permissions you granted, and the phase of the work — writing tools exist only in the acting phase of a goal, so a run cannot quietly change the world while it is supposed to be planning. #### Web and research | Tool | What it does | | --- | --- | | web_search | Search the live web. | | web_browse | Open and read a page, follow links, return the text with a pagination hint. | | deep_research | A longer multi-source investigation that returns a sourced report. | | tavily_extract | Structured extraction from a known URL. | | code_exec | Run code for data work, parsing and transformations. | #### Browser and computer | Tool | What it does | | --- | --- | | browser_act | Drive a browser step by step — click, type, select, scroll, paginate, upload, download, screenshot. | | computer_use | The same session at a higher level: a whole task, with read-back verification after every state change. | | save_login | Store a credential in the vault for a host. The value is never shown to the model afterwards. | | create_site_login | Register an account on a site using the employee’s own mailbox for the confirmation code. | | request_sms_code | Ask you for a phone code when a site demands one. | | check_social_profile | Read a public profile and check it against the platform’s own rules. | #### Deliverables | Tool | What it does | | --- | --- | | create_file | Write a file into the workspace. | | generate_document | Produce a document — report, commercial proposal, brief — and render it to PDF. | | generate_presentation | Build a deck from a brief and render it to a file. | | generate_image / edit_image | Create or edit an image. | | generate_video | Produce a video. Clips longer than one shot are filmed in segments and joined into a single file. | | deploy_site | Publish a site, instrument its forms and its traffic counter. | | connect_site_domain / check_site_domain / attach_site_domain | Attach your own domain to a published site — connect, verify DNS, bind the host. | | site_records_open | Allow a site form to write rows into a working table of the project. | #### Communication | Tool | What it does | | --- | --- | | send_email | Send from the employee’s own address or your connected mailbox. Checks the payment links inside before sending. | | provision_self_mailbox | Give the employee its own address. | | call_phone / end_call | Place a call and end it. | | send_messenger_audio | Send a voice note in a messenger. | | in_app_chat | Write into a chat room inside the platform. | | connect_app | Connect an external account through the connector catalogue. | #### Records and memory | Tool | What it does | | --- | --- | | list_contacts / upsert_contact / log_contact_activity / get_contact_thread | Read and maintain your CRM. Reading is capped per call and blocked entirely on a turn handling untrusted content. | | user_table_create / read / append / update_row / delete_row / update_schema / list | Working tables — the closest thing to a spreadsheet the employee owns. | | notes_write / update / list / delete / checklist_* | Notes and checklists. | | recall_memory | Look something up in memory beyond what was auto-recalled this turn. | | update_user_md | Write a fact about you into the right memory tier. | | read_team_memory | Read what the team learned. | #### Time and work | Tool | What it does | | --- | --- | | schedule_task / list_scheduled_tasks / cancel_scheduled_task | Create, list and cancel scheduled and recurring work. | | mark_calendar_busy / list_calendar_busy / cancel_calendar_busy | Hold and release time. | | assign_teammate_task / list_team_tasks / move_team_task | The team board. | | hire_teammate / staff_project | Extend the roster when the work needs a craft nobody has. | | delegate_to_worker / run_worker / create_worker_chain / manage_worker_workflow | Hand a job to a specialist pipeline and follow it. | | get_run_history / get_last_run | Look at what previous runs actually did. | #### Money | Tool | What it does | | --- | --- | | connect_payment_account | Connect your merchant account. Only the provider name passes through the model; the key never does. | | create_payment_link | Issue a payment link against your account. Every link the platform issues is registered, which is what makes an invented link detectable. | #### Self-configuration An employee can adjust itself within your guardrails: its knowledge base, its notes about you, its house rules, its schedule, its skill set and — with your permission — which tools it has. It can also ask for a permission it lacks, request a piece of information it needs from you, pause and resume itself, and record a reflection after a job. All of these are blocked on a turn that is handling content fetched from the outside world. > **Warning:** There is also an on-chain family (balances, transfers, swaps, staking, perpetuals on Solana, EVM chains and Hyperliquid). It exists, it is off unless the employee’s role calls for it, and it is the one family where a mistake is irreversible — treat its guardrails accordingly. ## Skills and playbooks `agents/skills` · https://neolit.ai/docs#agents/skills **Two ways an employee gets a procedure it did not invent.** #### Skills A skill is a named procedure — how to run a specific kind of job well. The employee always knows the names and descriptions of its skills; the content is loaded only when a skill is actually needed. That is why having many skills costs nothing until one is used. - Skills can come from the platform catalogue or be written for your employee. - A team that learns something durable turns it into a skill attached to every member. - Loading a skill is a visible step in the chat, so you can see which procedure a run followed. #### Playbooks A playbook is a deterministic pipeline: fixed steps, in order, with checkpoints — no model deciding what to do next. It is the right shape when the job is the same every time and you want it identical every time. A playbook run can be dry-run first, and side-effect steps are cached so an interrupted run resumes without doing the same thing twice. #### Playbook catalogues Beyond the marketplace roster there are role packs grouped by division — agency, go-to-market, marketing, product, research, finance, C-suite and more. They serve as storefront tabs and as the pool a project goal draws from when it has to staff itself. > **Note:** Cards that describe work the platform cannot actually perform — commands for somebody else’s CLI, operations on a code repository we do not have — are removed from those catalogues rather than shown and then failed. A card that promises work is a promise. ## Scheduled and recurring work `agents/schedules` · https://neolit.ai/docs#agents/schedules **How work happens on a clock instead of on a message.** An employee can hold scheduled tasks: one-off items with a due time, and recurring items with a cadence. Goals with a recurring mode ride the same machinery. Everything runs on the platform, not in your browser. - A due task is claimed exactly once even when several schedulers tick at the same moment. - A one-off failure backs off and retries a few times before it is marked failed; a recurring task simply re-arms for its next slot. - A task that has been running too long is treated as orphaned and either resumed — if it committed nothing — or honestly marked interrupted. Half-done side effects are never replayed. - Dependencies are respected: a task waits for the ones it depends on. - A task that has been queued for a long time gains priority, so a busy queue does not starve the oldest work. > **Tip:** A scheduled task is the right tool for "every Monday, do X". A recurring goal is the right tool for "keep this number moving, and tell me when it does". The first one repeats an action; the second one pursues an outcome. ## Sites your employee publishes `agents/sites` · https://neolit.ai/docs#agents/sites **A published page is a real deliverable with real obligations — and the platform enforces them before the page goes out.** An employee can build and publish a site. It starts on a platform address and can be moved to your own domain. Everything the page collects lands in your project, because the page itself has no database. #### What the server adds by itself Legal pages, canonical link, favicon, a social preview image built from your logo, structured data without invented ratings, sitemap, robots and a 404 page are added by the platform rather than requested in a brief. A warning after publication would not give you a second chance; a floor does. #### Forms - A form with no destination becomes an enquiry to your project, with spam protection attached. - A form declared as a record writes a row into a working table — an order goes into the orders table, not into your message inbox. This requires an explicit permission. - Every submission is attributed to the visit that produced it, so you can see which campaign brought a customer and not only which brought traffic. #### Your own domain You can attach a domain you own. The flow is: connect, publish the DNS records shown, verify, bind. Two things about it are worth knowing: - The set of DNS records is chosen by the server, not improvised, and it comes with the reason. A CNAME on a bare domain — or on a domain carrying your email — would kill your mail, so in that case you are given an address-based set instead. - The platform re-checks a pending domain by itself on a decaying schedule. You do not have to sit on the page pressing "check". - An unverified domain is explained with a measurement — "we cannot see the ownership record; we do see an A record pointing at this address" — rather than with "DNS may take a while". #### Traffic A published page carries a first-party counter — no third-party analytics. It reports views, visitors, sessions and key events, and it does not store your visitors’ raw addresses, agents or full URLs. > **Warning:** Publishing takes several attempts on average, and that is by design: the checks below run before the page is allowed out, and a refused publication tells the employee exactly what to fix. See "What done means". ## What "done" means `agents/acceptance` · https://neolit.ai/docs#agents/acceptance **For the four things an employee hands you, here is what you are entitled to receive and how to check it in about a minute.** These are not aspirations. Each line is held by a rule that runs before the work reaches you: some refuse the delivery outright, the rest ride along as a warning attached to the finished work. Where a line has no check behind it, it says so — an invented measurement is worse than an absent one. #### A published site | You are entitled to | How to check | | --- | --- | | It opens and reads on a phone | Open it on your phone: no sideways scrolling, the menu opens and closes | | A link to it shows a preview in a messenger | Send yourself the link in Telegram | | There is a picture, not only text | Scroll: at least one illustration in the body | | Someone can contact the business | Find an email, phone or messenger | | That contact is real, not invented | Write to it | | An enquiry can be left on the page itself | Submit the form and see it arrive | | No button leads nowhere | Click every one | | No filler text and no placeholders | Read it | | It is written in the language of the audience | Read the headline | | Search engines can find it | Look at the browser tab title | | The brand is yours | Logo and name in the header | | A buy button leads to a real checkout | Press it | | No secrets in the published files | Held by a rule, nothing for you to do | > **Note:** Not checked, and stated as not checked: how the page looks to a human eye after publication, keyboard accessibility, and load speed. Text contrast is measured and comes back as a warning. #### A deck or presentation | You are entitled to | How to check | | --- | --- | | It ends on what you asked it to end on | The last slide | | There is a way to reply inside the file | Find an address or a link | | That address is real | Write to it | | No empty slides and no duplicated headings | Flip through | | Real numbers, not "XXX" | The metrics slide | | Every number carries its period | "Revenue, June 2026", not "Revenue" | | It is in the language of the audience | Read the first slide | | Headings state a point, not a topic | "Retention doubled", not "Retention" | | It is not a wall of bullets | Flip through | | A pitch closes all its beats | Problem · why now · product · traction · money · market · team · ask | #### A commercial proposal | You are entitled to | How to check | | --- | --- | | All seven sections present | Flip through | | A price, not "on request" everywhere | The price section | | The offer has a validity date | Find the date | | The next step has a deadline | The last paragraph | | A contact | Find it | | In the client’s language | Read it | | Not longer than four pages | Page count | #### A social or messenger profile | You are entitled to | How to check | | --- | --- | | Every field the platform requires is filled | Open the public profile | | The bio is not cut off mid-word | Read it on the public page, not in the settings form | | The handle is one the platform will accept | Held by a rule | | One handle and one name across platforms | Compare two profiles | | Avatar and cover are different pictures | Look at the header | | The cover is the right size and not cropped badly | Open it on a phone and on a desktop | | The contact in the bio is real | Write to it | | The profile is in the language of the audience | Read the bio | | There is a link and it leads to the offer | Click it | | No unprovable claims like "number one" | Read the bio | | No second account was created | Search the platform for your name | #### True of all four - An invented contact is never cosmetic — it is a customer writing into a void — and the same rule blocks it on a page, in a deck, in a proposal and in a profile. - Where the platform has no evidence, it does not find a fault. A false refusal costs you a whole run, and it does not know what you never told it. - Costs are in ◆ everywhere, including in text the backend writes. ## Phone and voice `agents/voice` · https://neolit.ai/docs#agents/voice **An employee can hold a real conversation — in the browser and over the telephone network.** #### Two different things - **A voice conversation** — You talk to your employee live. It runs on a fast model chosen for latency rather than the one you picked for chat — a slow model on a live call is not a preference, it is a broken call. - **A phone call** — Inbound and outbound calls over a carrier. This runs a small, tightly-scoped loop: book and check time, raise a ticket, notify a channel, transfer, take a voicemail, end the call. #### What happens after the call The live loop only talks. When the call ends, a second, full-capability run starts and actually performs what was promised on the call — sends the email, books the thing, updates the record — and posts a recap into your chat. This is deliberate: doing real work mid-sentence makes for long silences on the line. - Silence is covered: if the first words take too long, the caller hears a natural filler rather than dead air, and again before a slow tool. - Answers on a call are short by construction — a few sentences, numbers spoken as words, no markdown, no URLs read aloud. - Call history and recordings live in the Calls tab. - Voice minutes and the model behind them are billed separately, both in ◆. > **Note:** Voice notes in messengers are a third, separate thing: an employee can listen to one and reply with one. ## The browser and sign-ins `agents/browser` · https://neolit.ai/docs#agents/browser **How an employee works on sites that were built for humans.** Each employee gets a real browser session, not a scraper. Cookies and logins persist between runs, you can watch the live view, and the session state is visible in the Browser tab. #### Signing in - Credentials live in a vault. The value is substituted into the form field by the platform itself — it is never shown to the model, never written into the action log, and never repeated back in chat. - Where a site requires a code by email, the employee has its own mailbox and can complete the loop itself. - Where a site requires a phone number, that is a delay rather than a wall: you supply the number and the code, and the run continues. - Where a site requires a legal entity, a licence, or a paid listing, that is your step — the platform says so instead of pretending to try. #### Honesty rules - "The page says we are not signed in" is treated as a wall, not as a result. A run cannot report success from behind a login screen. - Sending is only counted when there is an observable sign that it was sent — an open composer is not proof. - A browsing budget is enforced per turn, and calls that produce no new page, no new data and no completed action count as empty; three of those in a row end the browsing early instead of burning through the cap. #### What is underneath - Ten browser engines are available — hosted clouds and a self-hosted option on your own server, which is the default. If one provider is unavailable the work moves to another. - Residential proxies are available where a site treats a datacentre address as suspicious. - Captcha solving is included. A captcha is therefore not treated as evidence that a site is closed to us. - Reading is honest about its own blind spots: it reports when a page is a canvas it cannot read, when a list is virtualised and only part of it exists in the page, and how many pages of a paginated list are still unread. #### How it is tested The browser layer is the least predictable part of the platform, so it is tested hardest: dozens of live levels, a set of tasks against our own test site, hermetic checks that run with no model at all, and a nightly run against production. That is also why the documentation is willing to tell you what browsing still gets wrong — see "Known limitations". > **Note:** Two employees never share a browser profile. A worker that belongs to a project browses in the project profile — which is why its sign-ins can differ from what its personal dashboard shows. ## Channels `agents/channels` · https://neolit.ai/docs#agents/channels **How an employee reaches people outside the app.** | Channel | How it works | | --- | --- | | Email | The employee has its own address and can also use a mailbox you connect. Inbound mail lands in the Inbox tab and can start work. | | Telegram | Connect a bot for two-way conversation, including delivery of files and video. | | WhatsApp | Connect for messaging; sign-in to the web client is gated so a goal that needs it asks you rather than failing silently. | | Slack / Discord | Connect for team-facing work. A bot in your own workspace is an internal channel, not a cold outreach channel. | | Phone | Inbound and outbound calls with a realtime voice loop, call history, and post-call notes. | | Social platforms | Operated through the browser with a persistent signed-in session. | #### Rules the platform enforces on outreach - A first cold message never carries a checkout link. Ask first, sell second. - A payment URL in a message must be a link the platform actually issued. A shortened, retyped or invented link is blocked, and a truncated one is repaired by the server rather than guessed at by the model. - A second unanswered direct message is treated as pursuit, not as follow-up. Email sequences allow a small number of spaced follow-ups; direct messages do not. - When someone replies, the conversation belongs to the chat: the goal does not send a second message on top of a live thread. ## What an employee remembers `agents/memory` · https://neolit.ai/docs#agents/memory **Memory has two tiers, and the tier decides who else can see the fact.** #### Two tiers - **About you (account tier)** — Who you are, what your business is, how you like to work, your routine and preferences, and what has been learned about you in conversation. Every employee you own reads this tier — tell one of them your timezone and the others know it. - **About the work (workspace tier)** — Shared notes for this workspace, decisions taken, glossary, tool knowledge, and the employee’s own house rules. This stays inside the workspace it was learned in. The tier is chosen by the nature of the fact, not by where it was said. A fact about you goes up so your other employees benefit; a fact about a specific job stays down so it does not leak into unrelated work. #### You are in control of it - Memory documents are visible and editable in the Memory tab, each labelled with its reach. Empty documents are shown too, so you can see what could be filled. - When something is written to memory it appears in chat as a card with an undo button. Undo lives on that row forever, not just while the tab is open. - When the same fact has been observed twice, the platform offers to promote it to the account tier — you confirm, it does not promote itself. - When a fact is superseded, the old line is marked rather than deleted, and drops out of the prompt. A statement you wrote by hand is never overridden automatically. - Your biography is not writable by an employee. The only route to it is a promotion card you approve. #### What it asks you When nothing at all is known about you, an employee will add one question about your business to the end of an otherwise useful answer. The limit is counted per owner, not per employee, so ten workers do not ask you the same thing ten times, and silence counts as an answer. Autonomous runs never ask. > **Note:** Facts about you are recorded in your own language — taken from your profile setting, and otherwise from the language you actually write in. ## Guardrails, approvals and limits `agents/guardrails` · https://neolit.ai/docs#agents/guardrails **What an employee may do on its own, and where it must stop and ask.** - Nothing is connected by default. An account the employee can use is an account you connected. - Irreversible actions raise an approval card in chat before they happen. - Spending is bounded twice: by your wallet, and by the per-goal budget. A goal that exhausts its budget pauses; resuming without raising the budget returns it to the same pause, because spend does not go down. - When an employee runs into a missing permission, it asks for it as a one-click card in the conversation instead of sending you to a settings screen. - Content fetched from the outside world is treated as data. On a turn that is handling untrusted content, self-configuration tools are blocked, and reading your contact database is blocked outright — an injected instruction must not be able to exfiltrate your list. - Secrets never pass through the model. Payment provider keys are entered into a card in the chat, not dictated into the conversation, and are wiped from the client state after use. > **Warning:** An autonomous turn that announces an immediate action and then calls no tool gets exactly one extra iteration to follow through. This is deliberate: in a live chat "I will do it once you confirm" is legitimate, but in an unattended run it is not. ## Artifacts `agents/artifacts` · https://neolit.ai/docs#agents/artifacts **The shelf of things the work produced.** Any file, deck, image, video or published site the employee makes lands on the Artifacts shelf — on the employee, on the team, and on the project, depending on where it was made. Each item keeps the run it came from, so you can trace a file back to the goal and the moment that produced it. - A file is recorded at the moment it is created, not when the run ends — a run that later fails does not take your deliverable with it. - Rename and delete apply to both places the file is known, so a deleted file does not reappear. - The shelf filters by type — Site, PDF, Sheet, Document, Image, Video, File. A chip appears only for a type that is actually present. - Revise (the ✎ action) sends a note about that exact file. Where the file belongs to a goal, the note goes to that goal; where it came from a conversation, it goes to the conversation. > **Note:** A result in the feed with no artifact behind it is a report, not a deliverable. The interface distinguishes the two on purpose. ## Removing an employee `agents/delete` · https://neolit.ai/docs#agents/delete **What deletion takes with it.** Settings → Delete agent removes the employee and everything scoped to it: its chat, its memory, its goals, its tasks, and its membership in any team or project. You are returned to the marketplace. - The orchestrator cannot be deleted. - Contacts are not deleted with the employee — the contact database belongs to your workspace, and the employee is only the attribution on the record. - If you delete an employee and later hire the same listing again, the new copy is a new worker. It does not inherit the old conversation. --- # Goals _The autonomous half of the product_ ## What a goal is `goals/what-is-goal` · https://neolit.ai/docs#goals/what-is-goal **A goal is a stated outcome the platform will pursue without you sitting in the chat. It has a mode, a budget, a definition of done, and — at the end — a verdict with a reason.** An employee can hold several active goals at once; they are separate objects with separate budgets, logs and results. This is deliberate — collapsing them into "the current task" would hide the fact that three different pieces of work are in flight. #### What you supply - **The objective** — What should be true when this is done. One sentence, in your own words. - **The mode** — One result, a number to reach, or a repeating cadence. See the next article. - **The budget** — A ceiling in ◆. The goal pauses at the ceiling rather than continuing quietly. - **Advanced settings (optional)** — The metric, the schedule, the success criteria, and the axes of the work. Most goals never need these — the composer shows the objective, a human summary and a readiness check first, and hides the rest. #### What the platform supplies - A cadence with a stated reason — why this goal should run daily, or weekly, or once. - A readiness check: is the outcome reachable at all with the capabilities that exist, and does anything need to be connected first. - A plan. For a project goal, a plan of stages; for a solo goal, a route through the work. - A per-goal activity log with human-readable descriptions of every action. - A running commentary in the chat: took the goal, working, here is the result. ## Goal modes `goals/modes` · https://neolit.ai/docs#goals/modes **Three shapes of goal. Picking the wrong one is the most common reason a goal behaves unexpectedly.** - **Once** — One result. Not one run — one result. A retryable failure gets a small retry budget and another attempt after a delay. A file or a site is a result, not a pause: once the deliverable exists, the goal is done. - **Until target** — Numeric progress towards a number you name — replies collected, listings published, enquiries received. Progress is counted against the target, and the target is what decides completion. - **Recurring** — Independent occurrences on a calendar schedule, with a weekday pattern and a timezone. Each occurrence is its own piece of work with its own result. > **Warning:** Progress is always shown according to the mode. A targetless goal never displays "0 of 0" — if you see progress framed as a count where you asked for a single result, the mode is not what you intended. ## Start with AI `goals/start-with-ai` · https://neolit.ai/docs#goals/start-with-ai **If you would rather answer questions than write a definition of done.** Start with AI takes your rough objective and asks between one and three clarifying questions, one at a time, each informed by your previous answer. The card shows a stepper — question N of 3 — and keeps the answers you already gave visible. - The questions are about your context, not about the format: who the customer is, what already exists, what would count as success. - Your answers are woven into the definition of done and the strategy, so they shape the work rather than being discarded after the dialogue. - After the third answer the goal starts. If the model is unavailable, it starts anyway from your objective and your answers — there is no dead end where you answer questions and get nothing. - Before you accept the proposed goal, you can edit its wording. The edited text is what runs. ## The goal cycle `goals/cycle` · https://neolit.ai/docs#goals/cycle **What happens inside one run, and why runs are separated from results.** 1. Plan. The run works out the next concrete step towards the outcome, using what the previous runs learned. 2. Act. Tools that change the world are only available in this phase. This is why a goal cannot quietly write files while it is supposed to be thinking. 3. Verify. The run checks what actually changed — the page, the record, the metric — rather than accepting its own report. 4. Report. The result, its evidence and its cost go into the goal log and into the chat. #### The run acts with the methods it has A run is required to make a result now, with available methods, instead of proposing a project. Concretely: if a goal is about reaching customers and no channel was named, it uses the mailbox and your contact database; if the contact list is empty, it finds addresses and writes in the same run rather than making "import a list" the first step; if a report is asked for, it produces a document; if a page is asked for, it publishes a page. It does not answer a request for customers with a plan to build a landing page "to begin with". > **Note:** Runs are scheduled by the platform. You do not need to keep the tab open, and closing your laptop does not stop the work. ## Evidence and the outcome verdict `goals/evidence` · https://neolit.ai/docs#goals/evidence **Why the last line of a goal says "reached — because", and why a percentage is never the reason.** When a goal ends it carries a verdict: reached or not reached, and the reason. The verdict stands on the trace of the work — a delivered file, a confirmed effect, a live number that moved. It never stands on a completion percentage. That distinction is not cosmetic. A parent goal computes its percentage from live work, with unrecoverable failures removed from the denominator so a single impossible sub-goal cannot pin it at 75% forever. The side effect is that a goal with one closed sub-goal out of four can show the same 100% as one that fully succeeded. So the percentage tells you about motion, and the verdict tells you about outcome — and only the verdict is allowed to close the goal. - Without a trace, a goal cannot become "reached". It also does not hang forever: it stops with a stated reason and releases its slot. - The verdict is computed from the record, so it also exists for goals that closed a long time ago. - "Achieved" and "the agent wrote that it achieved it" are different states, and the feed marks which one it is showing you. #### Counting people and money Where the outcome is a number of people reached or money moved, the count comes from records — messages sent, contacts touched, payments registered — not from paragraphs of a report. Two different counters exist and mean different things: the number of tool calls a run made, and the number of confirmed effects of the target kind. Only the second one is evidence. ## Accepting a result `goals/review` · https://neolit.ai/docs#goals/review **The decision that closes a piece of work, and everywhere you can take it.** When a run produces something that needs your judgement, it opens a review. The same decision appears on the goal panel, on the chat card under the message that produced it, in the project feed, and in the NEO window. Answering in one place closes it in all of them. - Accepting is two-step everywhere. It irreversibly closes the work, so the first click opens a confirmation. - You can accept a result even when the file it expected is missing — the server names that door explicitly rather than making you guess. - Sending it back for revision keeps the goal alive and carries your note into the next run. - A review that has already been decided — elsewhere, by timeout, or on another device — explains itself rather than inviting you to retry something that will fail the same way. #### What happens if you say nothing The review window has an end, and what happens at the end is stated on the card. For a goal whose whole point was the deliverable, silence accepts the work. For everything else, silence pauses the goal, and resuming costs a fresh run. If the card does not state an outcome, it stays silent rather than inventing a default. > **Note:** Hiring a marketplace employee costs no more than creating one. There is no per-result fee: the only thing you spend is tokens. ## "Fix this": revisions and follow-ups `goals/revise` · https://neolit.ai/docs#goals/revise **Comments on a result, and what each one does depending on the state of the work.** A note about a result is a real instruction, not a comment field. Where it goes depends on the state of the goal: | State of the goal | What your note does | | --- | --- | | Waiting for review | Sends the work back as "needs work" with your note attached. | | Paused, and resumable | Saves the note and starts another run that carries it. | | Paused behind a wall resume cannot lift | Saves the note and leaves the door that can actually help. It does not promise a run that would not help. | | Finished work | Opens a follow-up — a new goal that references the file and the original task. Finished work accepts a comment; it does not come back to life. | | Archived | Declined, with the reason. | - A note is consumed by exactly one run: the run takes it into its instructions and clears it in the same transaction, so it cannot be applied twice. - Revision history keeps the chain — what it was, what you said, what came back — because a note lives for one run and two versions of a file otherwise sit on a shelf with nothing connecting them. - Follow-ups are capped per goal, and a double click does not create two of them. - The door always says what your note will cost before you click. #### Other places you can correct the work - A specific artifact: ✎ on the shelf or under the file in chat. - A work plan you disagree with: "not this", with the reason, which goes into the same feedback channel as review notes. - A proposed goal: edit the wording before accepting it. - Stages of a path: editable while they are still pending. - A candidate the platform proposed to hire: decline with a criterion, which is carried into the next search for that goal. ## When a goal stops `goals/stalled` · https://neolit.ai/docs#goals/stalled **Every stop has a named reason, and every reason has its own door. Resume is one of many.** A stopped goal is not a broken goal. It is a goal waiting for something specific, and the card names both the wall and the action that lifts it. The button you see is chosen by the server from the actual state — a single generic "Resume" everywhere would be wrong most of the time. | Wall | The door | | --- | --- | | Budget exhausted | Raise the goal budget. Resume alone returns it to the same pause, because spend does not decrease. | | Wallet empty | Top up. Sub-goals are put to sleep along with the parent so they do not keep spending unattended. | | Needs access to a site or account | Confirm access — sign in, or confirm you already have an account there. | | Needs a phone number or a code | Supply it. This is a delay, not a blocker. | | Needs a setup step from you | Complete the named setup. | | Needs an effect confirmed | Confirm what happened, or record the measurement. | | Needs a contact list | Import contacts, or let the run find addresses. | | Employee is inactive | Activate the employee. | | Needs a person for the work | Staff it — hire or build the specialist. | | Parent goal is asleep | Resume the parent; the whole cascade wakes with it. | | Out of reach of the platform | Stop only. The goal states what it cannot do rather than pretending a retry would help. | | Stalled — no movement | Three daily warnings without movement move it to a stalled pause, freeing the slot. | > **Warning:** The reason shown to you comes from the pause itself, not from the first item of a readiness checklist. A goal that paused because everyone on the list has already been written to will not tell you to "activate the employee". ## Budget and spend `goals/budget` · https://neolit.ai/docs#goals/budget **How a goal is bounded, and what happens at the ceiling.** - Every goal has a ceiling in ◆. Reaching it pauses the goal — it does not stop the work halfway through a run and it does not overspend. - The only thing that lifts a budget pause is raising the budget. This is why the door offered is "raise budget" and not "resume". - A budget pause on a parent goal puts its sub-goals to sleep as well, so nothing keeps spending under a goal you have stopped funding. - Resuming by hand resets the consecutive-failure counter; automatic resumption does not. Otherwise "failed, resumed, failed, resumed" would never end. - A goal whose path is planned as stages gets a ceiling that grows with the number of stages, so a longer path is not starved by a budget written for a shorter one. > **Note:** Everything an employee spends is visible per run in the goal log, per turn in the chat, and in aggregate in Billing. ## Outreach goals `goals/outreach` · https://neolit.ai/docs#goals/outreach **Goals whose outcome is "reach these people" behave differently, and the differences are enforced rather than suggested.** #### Who is being written to The audience is decided by a detector, not improvised per message: grants, investors, partners, suppliers, candidates, press, clients — first match wins, so "a grant from a fund" is a grant, not an investor. The audience changes what the message is for: an investor gets a thesis and a call, a grant gets criteria and a deadline, a customer gets their problem. Register follows the country of the market; where the country is not on the map, the run stays neutral instead of guessing. #### Which surface A messenger is not an email ladder with different plumbing. The platform distinguishes mailbox, voice, web form, personal direct message, social direct message, and public post — and applies the etiquette of each. A bot in your own Slack or Discord is an internal channel, not a cold one. #### The rules that never bend - No checkout link in a first cold message. - A payment link must be one the platform issued; invented links are blocked and truncated ones are repaired server-side. - A follow-up on email is bounded — a few spaced touches, then stop. - A second unanswered direct message is not sent. - A reply moves the conversation to the chat, and the goal stops writing into it. --- # Teams _Several employees, one group chat, one orchestrator_ ## What a team is `teams/what-is-team` · https://neolit.ai/docs#teams/what-is-team **A team is not a separate kind of object. It is a set of ordinary employees sharing a label, plus a group chat and an orchestrator that routes work between them.** That design has a consequence worth knowing up front: every member remains a full employee. It has its own memory, its own goals, its own channels, its own browser and its own dashboard. The team adds coordination on top; it does not dissolve the individuals. - A team lives at /team/ and opens the same dashboard shell in team mode. The Chat tab becomes the group chat; all the other tabs operate on whichever member is selected. - Clicking a member from the account menu or from the team collage opens that member’s own dashboard at /dashboard/ — one avatar, a private chat, all personal tabs, and a compact link back to the team. - A member avatar is a role glyph rather than a face. It tells you what the member does at a glance. - A member name in the database carries the team suffix because it is an identifier — it produces the dashboard URL and the @handle. The interface always shows you the readable label instead. ## Building a team `teams/build-team` · https://neolit.ai/docs#teams/build-team **Three doors into a team roster, all of them going through the same server-side entry.** - **Hire into the team** — From the team card, "Hire into team" takes you to the marketplace with a visible banner saying which team you are hiring into. After you hire, the new employee is attached and you land back in the team. - **Create an employee for a brief** — "Create employee" opens a brief box. The server derives the role, generates the knowledge, crawls the references, attaches the member and posts a note into the group chat. The request runs for minutes and shows the real stages — do not close it. - **Add someone already working** — An existing employee can join, and its access moves with it: browser profile and provider, the login vault as ciphertext, and live sessions. Data — CRM, history, memory, notes — does not move. All three go through one server-side join. That is what enforces the size limit, checks the team is still alive, guarantees the handle is unique, inherits the team settings, and writes the note into the chat. A hire that fails to join is not rolled back — you did buy the worker — but it is reported separately rather than silently. > **Note:** The same listing can staff several teams. Each copy is a separate worker with its own memory, goals and chat, so hiring the same specialist into two teams is normal, not a duplicate. ## Team chat and handoffs `teams/team-chat` · https://neolit.ai/docs#teams/team-chat **How work moves between members.** - You write to the team, not to a person. The orchestrator decides who takes it, and you can address someone directly with an @mention. - Every reply is attributed to a member, with their role glyph. - A handoff between members appears as a step row naming the recipient. - A step that is running is upgraded in place when it finishes — you see one row change state, not two rows. - Broadcasts to the whole team are marked as such. - What a turn cost appears as a compact ◆ line. A member taking a turn gets its own full context — its knowledge, its skills, its memory — plus a team frame describing the current situation. It does not carry the history of its private chat into the group; the two conversations stay separate on purpose. The roster refreshes by itself: on a live tick, when a membership note arrives, and at the end of a team turn. A member hired automatically by a goal shows up without a reload. ## The board and delegation `teams/team-board` · https://neolit.ai/docs#teams/team-board **Where team work is visible while it is happening.** A team keeps a board of cards. A card can be put there by you, by the orchestrator, by a member handing work over, or by a goal. It carries who it is for, what it depends on, and its own history of events — claimed, done, failed, retried, re-queued. - Cards move through pending, running, done, failed, cancelled and backlog, and the allowed transitions are enforced — done, failed and cancelled are terminal. - A member cannot be buried: there is a cap on how many open cards one member can hold, and a separate cap on how much work the team may queue for itself automatically. - A card can depend on other cards, and it waits for them. - A synchronous delegation is mirrored onto the board, so a handoff that happened inside one turn is still something you can see afterwards. #### Budget A team can carry a monthly ceiling. At eighty per cent of it the answer to your message carries a warning; at a hundred per cent a turn refuses with a plain note rather than quietly spending past the line. What a turn cost appears as a compact ◆ figure under the answer. ## Review, loops and what a team learns `teams/team-learning` · https://neolit.ai/docs#teams/team-learning **How a team improves the work before you see it, and how it keeps what it learned.** #### The review loop A team can be set to work in rounds instead of a single pass. The acceptance criteria are fixed once at the start so the scale cannot drift, then each round revises the previous attempt against the reviewer’s feedback. A round is judged either by a designated reviewer on the team or by an independent judge that is deliberately not the model that produced the work — self-grading is not grading. It stops when the work is approved, when it reaches the score you asked for, when it plateaus, or when it gets clearly worse than its own best attempt. What you receive is the best round, not the last one. #### Lessons - Recurring friction — the same kind of failure appearing again and again — is distilled into a short lesson the whole team carries. One lesson per pass, never a wall of them. - A success becomes a lesson immediately; friction has to repeat before it counts, so a single bad day does not become doctrine. - You can veto a lesson. A vetoed one is blocked permanently, not just removed. - A lesson that keeps being needed is reinforced; one that keeps failing is rewritten from scratch or dropped. - Every distillation is visible in the chat as its own row — a team does not learn behind your back. #### Reliability The platform keeps a rolling record of how often each member finishes what it takes. It is used as advice inside the team frame — never as a gate. A member is not starved of work over one bad run. ## Team rules and limits `teams/team-limits` · https://neolit.ai/docs#teams/team-limits **The constraints worth knowing before you design a roster.** - A team holds up to ten members. The limit is enforced on the server; the interface simply greys the button out early. - A team and a project are mutually exclusive for a given employee. An employee is in one or the other, never both. - A member already in someone else’s team is not moved silently — that requires an explicit move. - Team settings are inherited by new members through one shared path, so a capability you granted the team applies to whoever joins next. - A member’s boundaries are never invented. Empty means nothing is forbidden. --- # Projects _A container for a business: market, strategy, work, metrics_ ## What a project is `projects/what-is-project` · https://neolit.ai/docs#projects/what-is-project **A project is the container in which a business is worked on. It holds the market, the strategy, the shared knowledge, the materials, the board, the feed, the metrics, the contacts and the goals — and it injects all of that into every turn every member takes.** The difference between a project and a team is the subject. A team is a group of workers. A project is a business those workers are working on: it survives changes in the roster, it accumulates knowledge, it has an economy and it has an opinion — the strategy — that the work is measured against. #### The seven zones - **Overview** — Health, current focus, what changed, the last result, and spend. The launch map lives here — what is done, what is running, what has not started, and what we simply cannot see. - **Metrics** — Business KPIs and site metrics, each carrying its provenance. - **Review** — The profile map, owner decisions, and the things waiting on you. - **Knowledge** — Library, shared memory, research and confirmed facts. - **Strategy** — The line you have accepted, versioned, with decisions and their provenance. - **Work** — Goals, stages, sub-goals, the board. - **Settings** — Identity, market, languages, visibility, budget, notifications. The composition of the project — which employees and which whole teams belong to it — lives in the sidebar card and in the account menu rather than in a tab of its own. Contacts and the admin inbox are also sidebar surfaces. ## Creating a project `projects/intake` · https://neolit.ai/docs#projects/intake **A guided intake that ends with one main goal and a plan of stages.** 1. About — what the business is. If you have a site, it is read and the facts found on it are recorded as facts, attributed to the site. 2. Market — country, language of your customers, currency, timezone, and the channels through which the market can actually be reached. 3. Questions — a short set of clarifications, answered one at a time. 4. Review — what the platform understood. Correct anything that is wrong here; this text becomes the project profile. 5. Objective — the main goal, and then the stages of the path towards it. - Nothing is written to the database until the final button. You can abandon the intake at any point. - "I do not know" is recorded as "not known", never converted into an invented fact. - The resulting profile becomes the shared memory of the project, which every member then reads. > **Tip:** Spend the time on the Review step. Everything downstream — strategy, channel choice, the wording of goals, the language of your customer-facing pages — is derived from what you confirm there. ## Market, languages and currency `projects/market` · https://neolit.ai/docs#projects/market **The project market is four facts, and they decide more than they look like they do.** A market is a country, a customer language, a currency and a timezone. The country decides which platforms are real for this business, which advertising systems are even available, and the register of business correspondence. The language decides what your customers read. #### Two languages, not one - **Customer language** — Pages, emails to customers, documents, form and table captions — everything the market sees. - **Your language** — Goals, plans, strategy, run reports, intake questions, research summaries and the letters the platform writes to you. These are separate settings for a reason: an owner selling abroad would otherwise lose their own language the moment they told us who their customers are. Your language is taken from your explicit setting, then your profile, then the language you actually write in — and never from the customer side. - The list of customer languages is built from the countries of the market, not from the interface locales. Any real language code is accepted, including ones the interface itself does not have. - Advertising options are localised to availability, not merely translated — an advertiser in a country where a global network is unavailable is offered the networks that actually work there. - Money in your project is displayed in your project currency. Platform spend remains in ◆. ## Channels and the cost of entry `projects/project-channels` · https://neolit.ai/docs#projects/project-channels **How the project decides where to reach customers, and in what order.** Every channel has a cost of entry, and that cost decides the order of the work. The tiers, cheapest first: | Tier | Meaning | | --- | --- | | Have | You are already there. An account you already own is the first channel, always — including platforms outside our catalogue. | | None | Works without an account. | | Email | Registration completes with an emailed code, which the employee can do end to end with its own mailbox. | | Phone | Needs a number and a code from you. A delay, not a wall. | | Owner | Needs a legal entity, a licence, or payment. Your step, and the platform says so. | | Unknown | Not verified. Deliberately ranked with the walls rather than ahead of a proven channel — planning work on a guess is worse than planning it on a known cost. | - A channel carries a reason and an owner: "who runs this" is stated separately, because promising work the platform will not do is the same as promising nothing. - What a live run learns overrides the guess, for you only. A wall one owner hit may be their region or their VPN, so it corrects your project rather than the shared catalogue. - The reason for a wall decides what it disproves. A paywall proves the tier is "owner"; two-factor proves "phone"; a login wall only disproves "no account needed"; a captcha proves nothing at all, because the platform solves those. - Reading a site is not working a channel. A platform where you can only read reviews is not a door to a customer. - A tool a contractor sells is not a channel. Those are filtered out of the catalogue. > **Note:** For many markets the honest first channel is your own page plus letters to a list you build. The planner says that in as many words rather than sending the work at a platform that will stop it at registration. ## What members see every turn `projects/context` · https://neolit.ai/docs#projects/context **The project context block, and why it is deliberately small.** Every turn of every project member carries a block describing the project: what it is, who the market is, what the strategy says, what the current focus is, what has already been done, and what is available. That is what makes a project member behave differently from the same employee working solo. - The block is capped. It rides in every single turn, so an extra paragraph is an extra cost on every message — the ceiling is a deliberate budget, not an oversight. - The project inventory is part of it: what the project already has — pages, tables, accounts, materials — so a run does not propose building something that exists. - Contacts, notes and tables are read across two layers for a project member: the project workspace and the employee’s own. Otherwise a member would answer "the CRM is empty" while looking at a full database. ## Knowledge Hub `projects/knowledge` · https://neolit.ai/docs#projects/knowledge **Everything the project knows, in four drawers.** - **Library** — Materials and artifacts — files you uploaded and files the work produced, with the same type filters as the employee shelf. - **Memory** — The shared memory of the project, starting from the profile the intake produced. - **Research** — Background analysis of the business from several angles, plus competitor discovery. Research and competitor scanning are separate operations with separate outputs. - **Facts** — Confirmed facts, each with a source. A fact found on your site is attributed to your site; something nobody could verify does not become a fact. Background analysis runs by itself after intake and produces reports rather than opinions. Everything a machine concluded stays a proposal: the profile, the strategy and every goal require your decision. ## Strategy and decisions `projects/strategy` · https://neolit.ai/docs#projects/strategy **The line you have accepted — versioned, with each decision carrying its own provenance.** The strategy holds decisions: who the segment is, which channel, what the offer is, what the price is, and what you are explicitly not doing in this period. Each decision carries a level of proof. - **Hypothesis** — Proposed but untested. Everything starts here, including things a model suggested in the first minute. - **Tested** — Work has happened under this decision — computed by the server from goals that closed successfully with a trace, not claimed by the text. - **Confirmed** — Only you can set this, with a button. "Work happened" is not the same as "the hypothesis was right". - Editing the text of a decision returns it to hypothesis. That is not a demotion — it is a different decision, and it is also the only way to undo a mistaken confirmation. - Decisions depend on each other. Change the segment and the channel, offer and price chosen for the old one are stale — the platform says so in a line and leaves the judgement to you. - A strategy has a period. "What we are not doing" without a horizon reads as a permanent ban six months later. - Versions are kept, and the difference between two versions is computed by one shared comparison so the revision card, the proposal card and the history never disagree about what changed. > **Note:** The strategy text is also read by the work. Fields drive the planning; the free text is for you, and editing it does not silently change a decision. ## Goals, stages and staffing `projects/work` · https://neolit.ai/docs#projects/work **How a project turns one objective into work that gets done.** #### Stages Intake sets one main goal; the path to it is a plan of stages. A stage lives in the parent plan until a sub-goal is created for it, at which point the sub-goal tells the story of the work. There is deliberately no "done" state on the plan itself — the work is what reports, not the outline. Stages are editable while they are still pending. #### Waves of sub-goals The parent goal produces sub-goals in waves, each carrying a note from the parent about what was learned. Sub-goals run, report and close; the parent tracks the path. A failed sub-goal can be replaced by one that inherits its stage, so the path is not abandoned because one attempt failed. #### Staffing When a goal needs a craft the project does not have, it can extend the roster through four doors, in order: the existing roster, the marketplace, the playbook catalogues, and finally building a specialist from scratch. Building is the strictest — it is limited per goal — and the platform prefers building your own over hiring an approximate match. - A candidate must match the whole platform name or the craft. A partial name match — one word of a compound brand — is not a hire. - You can decline a candidate with a criterion, and that criterion is carried into the next search for this goal. - Auto-hiring shares one cap across the marketplace and the catalogues. ## Autopilot `projects/autopilot` · https://neolit.ai/docs#projects/autopilot **How a project decides what to do next without being asked.** When a goal ends, the project reads its outcome and decides whether there is a next goal worth proposing. Signals come from grounded facts: a measured gap between where a metric is and where it should be, a failure that suggests a different route, and — equally — a success. - Success is a signal too. A project without a pinned KPI used to go quiet after a win; "we did this" now feeds the loop as well, ranked last so it never displaces a measured gap. - An empty project does not come alive on its own. With no closed goals there is nothing to reason from. - A proposed goal is a proposal. You can edit its wording before accepting, and the edited version is what runs. - A goal that stalls — no movement across three daily warnings — moves to a stalled pause and frees its slot, so the autopilot is not blocked by work that stopped progressing. ## Feed and what needs you `projects/feed` · https://neolit.ai/docs#projects/feed **The single page where the project tells you what happened and what it needs.** The feed is the project’s narrative: goals taken, work done, results produced, decisions waiting. Above it sits a strip of things waiting on you — each row names the action, not a general status, and clicking it takes you to the row where the decision actually lives. - The strip does not decide anything itself. It is a signpost to the door, deliberately not a tenth door. - It is scoped by the feed filter: filter to one goal and you see only that goal’s waiting decisions. - An intention is not a fact, and the feed says so — what was planned, what is happening now, and what actually resulted are visually different things. - A goal card answers three questions: who is on it, what it is, and what results exist. It also separates what is being done right now from what has been done before. - An outcome is not only success. A goal that ended without reaching its target says so, with the reason. - Key events give you a fast pass through the feed when you do not want the full story. ## Metrics and revenue `projects/metrics` · https://neolit.ai/docs#projects/metrics **Numbers with provenance, measured by our own tracker rather than borrowed from an analytics vendor.** #### Site metrics Pages the project publishes are instrumented with a first-party counter. It reports pageviews, visitors, sessions and key events over the last 30 days against the previous 30. The collector accepts only a known site key from an allowed origin, and it does not store a raw IP, a user agent, or a full URL. #### Business KPIs Manual KPIs — recurring revenue, active customers, churn, or your own custom metric — sit alongside the automatic ones. Every point carries where it came from: measured by us, or reported by you. A goal can be set on a metric, and it is that live number that decides whether the goal was reached. #### Revenue Revenue can be connected from your own payment account. That is your merchant account, not ours — the money the platform itself takes for tokens is a different thing entirely and never appears as your project revenue. Costs and cash left over are things a payment provider cannot know, and they stay with you. #### Attribution - An enquiry inherits the campaign label of the visit in the same session. The browser names only the session; the campaign is read on the server from that session’s events, because attribution written by the same party that could fake it is not attribution. - The campaign is stored on the enquiry itself rather than joined at read time, so it stays true about that day even after the campaign is renamed. - Attribution enriches, it never gates: if the session is missing, the enquiry is still saved. - Orders from your site are counted as their own number, not added to enquiries — summing them would inflate both. - There is no cost-per-lead, ROAS or CPA, and there will not be. What you spend inside your own ad account is not visible to us, and a number derived from a guess would be worse than no number. ## Enquiries, clients and site records `projects/admin` · https://neolit.ai/docs#projects/admin **Everything about people, in one queue.** The admin surface is a work queue, not a wall of counters. It has three parts: - **Inbox** — Enquiries from your sites, triaged by bucket (open, archived, all), by status, by kind, and by how long they have been waiting. Search covers name, contact, message, and which site and page it came from. - **Clients** — The people behind the enquiries, with a stage you can move them through. - **Tables** — Working tables of the project — including records submitted directly by a site form. #### How a site talks back to the project A site the project publishes has no database of its own. Anything a visitor submits lives in the project. There are two distinct things a form can be: - An enquiry — a message. Any form without its own destination becomes one automatically, with spam protection attached. - A record — a row in a working table of the project, for example an order. This requires an explicit permission you grant; there is no public read of records at all. > **Warning:** The distinction matters: if a record form were auto-wired as an enquiry, an order would arrive as a message and never reach the table it belongs in. #### Contacts Your contact database is yours: import a CSV, search it, page through it. Contacts are identified by email, phone, and handles on platforms — a Telegram username is an identity in exactly the same way an email is, because it is how a conversation is opened. A contact loaded from a file is marked as imported: importing is not evidence, and an imported address does not by itself become something the platform will publish. ## The public project page `projects/public` · https://neolit.ai/docs#projects/public **A link-in-bio page for the project at /p/.** - It requires no login and shows what the project chooses to show. - It exists only while you have set the project visibility to link. Otherwise the API returns nothing at all — the page is not merely hidden, it is not served. - It is a separate surface from a site the project publishes. The public project page is about the project; a published site is a product of the work. ## Project settings `projects/project-settings` · https://neolit.ai/docs#projects/project-settings **What you can change after intake.** - Identity: name, logo (uploaded or generated), description, social links. - Market: country, customer language, your language, currency, timezone. - Tone: how members answer. - Visibility: whether /p/ is live. - Budget: a project ceiling that genuinely stops new project-attributed work. An explicit override lives here too. - Email notifications: which digests and alerts you receive. > **Note:** Members can change some of these themselves from within their work, through the same single path the settings screen uses — so a change made by an employee and a change made by you cannot disagree. --- # NEO _The orchestrator window_ ## What NEO is `neo/what-is-neo` · https://neolit.ai/docs#neo/what-is-neo **A floating window available on every page: one place to see open decisions, launch work and talk across the whole workspace.** NEO is an orchestrator rather than a worker. It knows your workspace — your employees, teams, projects, schedules, notes and tables — and it knows the page you are currently on. It is the right place to ask "what is waiting on me", "run this now", or "which of my people should do this". - It is opened from the sphere in the corner of any page. - Channels — Telegram, WhatsApp, Slack, Discord — connect from the plus button in its header, and a voice call starts from the handset next to it. These are the same channels an employee uses. - It cannot be deleted; it is part of the workspace rather than a hire. ## Doors, the badge and decisions `neo/neo-doors` · https://neolit.ai/docs#neo/neo-doors **The number on the sphere is a promise, and opening the window keeps it.** - The badge counts open doors — decisions the window can actually resolve. It is not an unread-message count. - Open doors are drawn above the conversation, not at the end of it. A badge that promises a card and then hides it under a scroll of chat history is a broken promise. - A door is only shown while the decision is genuinely open. "This goal has a run awaiting review" and "this review can be decided" are different questions, and only the second one puts a card in front of you. - Review cards in NEO are the same ladder as in the dashboard: an error or a busy state belongs to the individual card, so one click cannot grey out four unrelated decisions. - Accepting a result without the expected file is possible when the server says that door exists — it is named explicitly rather than surfacing as a generic retry. - A decision that has already been closed — elsewhere, by timeout, or by an expired window — explains itself instead of inviting a retry that would fail identically. ## Running work from NEO `neo/neo-run` · https://neolit.ai/docs#neo/neo-run **Starting a pipeline and getting the result in the same window.** You can launch a worker pipeline directly from NEO, and the result is delivered into that conversation. It is not started somewhere else and mirrored back — the run is addressed to NEO, so the window you started it from is the window that reports. > **Note:** Navigation offers from NEO are ordinary links: it will point you at a page rather than driving your browser for you. --- # The platform _The stack underneath: models, browsers, connectors, apps_ ## What Neolit runs on `platform/stack` · https://neolit.ai/docs#platform/stack **One hire gets the whole stack. Nothing here is a setup step for you — it is what is already wired in behind every employee.** | Layer | What is there | | --- | --- | | Ready-made employees | 1,100+ role-specific listings plus the playbook catalogues. | | Models | 30+ across every major provider, routed per job. Nothing for you to choose, subscribe to, or plug in. | | Browsers | Ours by default, plus nine browser clouds you can point it at with your own key. Residential proxies on your key; captcha solving included. | | Connectors | 37 one-click OAuth integrations. | | API catalogue | 371 services ready to use with your own key. | | Interface languages | 11. | #### Research and data Web search and crawling run on dedicated providers rather than on a model guessing from memory — Tavily, Exa, Parallel, Brave Search, Firecrawl and Jina Reader. These are included; adding your own key for one of them, or for another provider in the catalogue, makes the work run on your account instead. #### Browser engines The default browser is ours and runs on our infrastructure — there is nothing for you to host, and no server of yours involved. Nine browser clouds — Hyperbrowser, Browserbase, Anchor, Kernel, Notte, Steel, Browser Use Cloud, GoLogin and Camoufox — become available for a run the moment you add your key for one in Apps. Residential proxy pools work the same way; captcha solving is included and needs no key from you. #### Connectors One click each: HubSpot, Pipedrive, Salesforce, Apollo · Gmail, Outlook, Brevo, Resend, SendGrid · Google and Outlook Calendar · Slack, Discord, Telegram, Microsoft Teams · GitHub, GitLab, Jira, Linear · Notion, Google Sheets, Airtable, Google Drive · Asana, Trello · Shopify · Stripe · Twilio, Vonage · ElevenLabs · PostHog, Segment · Zapier · Google Meet, Zoom, Cal.com, Calendly. #### Channels Email from your own verified domain with SPF and DKIM, plus Telegram, WhatsApp, Slack, Discord and Microsoft Teams. Voice runs over seven carriers — Twilio, Telnyx, Plivo, Vonage, Voximplant, AgentPhone — with ElevenLabs for the voice itself. #### Money Merchant accounts your employee can invoice through: Creem, Paddle, Dodo Payments, Polar and Lemon Squeezy. The money lands in your account with that provider, not in a balance we hold for you — there is no wallet, no escrow and no on-chain settlement anywhere in the product. #### Media Images through MiniMax Image-01 and Gemini Flash Image; video through ByteDance Seedance and Google Veo; speech and transcription through ElevenLabs and Whisper. Image generation and transcription can run on your own key if you add one; video generation is platform-only and always runs on ours. #### What is not in it - No model of your own. There is no place to paste an OpenAI, Anthropic or other model key, and no way to run the platform on your model subscription. The model is ours, routed per job, and its cost is inside the ◆ price of a run. - No self-hosting. Neither the browser nor the platform runs on a machine of yours. - No wallet, escrow or on-chain money. - No ad accounts operated, no live backends deployed, no public API for your own code. Each of those has its own line in Known limitations. > **Note:** The full catalogue — 371 services across AI, blockchain data, finance, geo, media, security, communications and more — is on the Stack page, and every one of them works the moment you add your key. Note the difference: those are ordinary REST services your employee calls on your behalf, not the model that thinks for it. ## Models, and how one is chosen `platform/models` · https://neolit.ai/docs#platform/models **You are not buying a model, and you do not pick one. Different jobs on the platform deliberately run on different models, and the routing is ours.** Available across the platform: the MiniMax family, GPT-5.6 and 5.4 including Pro, o3, GPT-4o, Claude Opus 4.7, Sonnet 4.6 and Haiku 4.5, Gemini 2.5 Pro and Flash, DeepSeek V4, GLM, Kimi K2.7, and more through OpenRouter. #### There is no model setting This is worth stating plainly, because platforms like this one usually have a dropdown: Neolit does not. There is no model picker in the employee’s settings, no model key to paste, and no way to point the platform at a subscription of yours. Which model runs a given job is decided per job, by us, and the cost is already inside the ◆ price of that turn or run. #### Which job runs on what - **Chat and the work itself** — A strong general model. This is what answers you and drives the tools. - **The live-voice model** — A fast one. This is a latency constraint of the surface — a thoughtful model makes for dead air on a phone call. - **The browser driver** — A separate, small model that translates an instruction into a click. It is deliberately not a reasoning model: thinking before every click made reading a page take twenty seconds instead of one, and burnt the run’s budget before the task was done. - **The judge in a review loop** — Deliberately not the model that produced the work — a same-family judge approves its own output and the loop stops catching anything. - **Compaction and distillation** — A cheap model. Summarising does not need the expensive one. - **Project research and strategy** — Their own roles, with a fallback model if the first one refuses or times out. #### What you can bring, and what you cannot | Kind of key | Can you add it? | | --- | --- | | A model provider (OpenAI, Anthropic, …) | No. There is no surface for it and no benefit — model cost is part of the run price. | | One of the 371 catalogued API services | Yes, in Apps. Stored encrypted, used immediately, never shown to the model. | | A browser cloud or residential proxy | Yes, the same way. The run then uses that engine instead of ours. | | Search, scraping, image or transcription providers | Yes. Video generation is the exception — platform-only. | #### What a turn costs Model usage is metered per turn and shown in ◆ under the answer, per run in a goal log, and in aggregate in Billing. Long conversations are compacted rather than truncated, so an old thread does not silently start forgetting. ## Apps, connectors and your own keys `platform/integrations` · https://neolit.ai/docs#platform/integrations **How an external account becomes something your employee can use.** #### Three ways in - **A connector** — One click, OAuth, done. Thirty-seven of the tools teams actually use. The employee gets the account, not your password. - **Your own API key** — For the 371 services in the catalogue. Stored encrypted, usable immediately, never shown back to the model. - **The browser** — For everything with no API at all — which is most of the platforms a small business actually sells on. The employee signs in like a person and keeps the session. Connections live in the Apps tab of the employee, and are visible to the work as part of what it can do. A run that needs something you have not connected asks for it as a card in the conversation rather than failing silently. > **Warning:** A connected account is real authority. Connect the account you want the work done in — a personal mailbox connected "just to test" will be the mailbox your customers get email from. > **Note:** None of this covers the model. The keys you add here are for services your employee calls; the model it thinks with is routed by the platform and has no key of yours. See Models for the full split. ## The API catalogue `platform/catalog` · https://neolit.ai/docs#platform/catalog **The 371 services on the Stack page, what they are for, and what adding a key actually changes.** A catalogued service is an ordinary REST API your employee already knows how to call: the address, the authentication scheme and the shape of a request are stored, so the only thing missing is your key. Paste it in Apps and the service is usable in the next turn — there is no integration step, no waiting on us, and no code. #### What is in it | Category | Count | Typical use | | --- | --- | --- | | AI and ML | 53 | Extra models, speech, translation, image tools beyond the ones included. | | Marketing, SEO and social | 39 | Lead enrichment, email verification, rank tracking, scheduling, influencer data. | | Crypto and Web3 data | 37 | Chain explorers and market data — read-only data, not money movement. | | Maps, geo and weather | 27 | Geocoding, places, local conditions. | | News and media | 26 | Press coverage, stock imagery, film and music databases. | | Dev and cloud tools | 25 | Screenshots, PDF conversion, hosting and monitoring APIs. | | More integrations | 23 | Everything that fits no single shelf, including marketplaces and search APIs. | | Ecommerce and retail | 20 | Marketplaces and storefronts by country. | | Finance and market data | 18 | Prices, fundamentals, exchange rates, property data. | | Gov, science and open data | 16 | Registries, research corpora, public statistics. | | Productivity and work | 14 | Task trackers, docs, spreadsheets, support desks. | | Sports and lifestyle | 12 | Fixtures, results, nutrition, fitness. | | Messaging and social platforms | 12 | Platform APIs beyond the one-click connectors. | | Browser clouds | 11 | Run the browser on that provider instead of ours. | | Email and notifications | 9 | Transactional senders and push. | | Scraping and crawling | 8 | Alternatives to the crawler included by default. | | Residential proxies | 5 | A residential exit for the browser. | | Security and OSINT | 10 | Reputation, breach and infrastructure lookups. | | Web search | 3 | Alternatives to the search included by default. | #### What adding a key changes - The service becomes callable. Before the key, a run that needs it says so and asks; after it, the call just happens. - The bill moves. Work done on your key is billed by that provider to you, and stops being metered as platform cost for that part. - The key is stored encrypted and is never shown back to the model — the employee uses it, it does not read it. - For browser clouds and proxies, the key also switches the engine: the run leaves our browser and goes to theirs. > **Warning:** The crypto category is data, not money. Chain explorers and price feeds are readable; there is no wallet, no signing and no on-chain payment anywhere in the product. > **Note:** A model provider is not in this catalogue in the sense you might expect. You can add an AI service key and have your employee call it as a tool, but that does not change the model the employee itself thinks with — that one is routed by the platform. See Models. ## The Mac app `platform/mac` · https://neolit.ai/docs#platform/mac **Your employees on the desktop.** There is a native Mac app for Apple Silicon and Intel, with automatic updates. It mirrors the surfaces you use most — chat, goals, and the decisions waiting on you — so a result you accept there is accepted everywhere, and a review closed on your desktop is closed on the web the moment the page refreshes. Download it from the link in the site header. Everything in these docs applies to it; where a surface is missing, the web app has it. ## Programmatic access `platform/access` · https://neolit.ai/docs#platform/access **What you can automate against today, and what does not exist yet.** - There is no public API for third-party developers, and no API keys to issue. The interface, the Mac app and the channels are the ways in. - Your employee, on the other hand, is an API client: it can call any HTTP service, and 371 catalogued services work as soon as you add a key. If you want something integrated, the shortest path is usually to ask your employee to integrate it rather than to wait for us. - Sites your employee publishes accept submissions from the public — enquiries and records — and those are the supported way for the outside world to write into your project. - Data you can hold in your hands: every artifact is a file you can download, tables export, and contacts import and export as CSV. > **Note:** If you need a real integration API, say so through Support. This page will say so when it exists — and until then it says it does not. --- # Money and plans _Tokens, billing, and getting paid by your own customers_ ## Tokens (◆) `money/tokens` · https://neolit.ai/docs#money/tokens **Everything you spend on the platform is counted in tokens. There is exactly one currency for cost, and it is this one.** A token is the unit of work the platform performs for you: model calls, browser time, generated media, sent messages. Costs are shown per turn in the chat, per run in a goal log, and in aggregate under Billing. #### What is metered separately | Kind of work | How it is counted | | --- | --- | | A turn | By what the model actually read and wrote. Shown under the answer when it is worth showing. | | A goal run | Everything the run consumed, against that goal’s ceiling. | | Voice | Per minute of call, plus the model behind it counted separately. | | Video | Per second of finished footage. A longer clip filmed in segments is charged for what it produced. | | Images and documents | Per generation. | | Browser | Per call, with a per-turn budget that ends browsing early when calls stop producing anything new. | #### Where dollars are allowed to appear - The price of a token pack — the point where real money enters the system. - Business results that belong to you: revenue your customers paid, the value of a deal closed. That is money you earned, not money you spent. Anywhere else, a cost is a ◆ figure. That includes text written by the backend and shown to you verbatim — an event line in a project feed, a note about a team budget, the reason a cycle stopped, a line in a review. If you ever see a dollar figure presented as your spend, that is a defect. > **Note:** The wallet is the real gate. A plan is a display layer over your balance; what is actually checked before any paid action is the balance itself. ## Plans and billing `money/plans` · https://neolit.ai/docs#money/plans **What each plan gives you, and how a purchase works.** | Plan | Tokens | Price | | --- | --- | --- | | Free | ◆ 2,000 | $0 | | Starter | ◆ 10,000 | $5 / month | | Growth | ◆ 100,000 | $20 / month | - New accounts start on Free with a welcome balance, so real work is possible before any payment. - Checkout is a redirect to the payment provider’s own page. There is no payment SDK running inside Neolit, and no card details ever touch our pages. - After payment you return to the app, the subscription webhook grants the quota, and the interface picks up the new plan. - Hiring a marketplace employee costs nothing beyond the tokens its work consumes — there is no per-hire fee and no fee on an accepted result. ## Getting paid by your customers `money/owner-payments` · https://neolit.ai/docs#money/owner-payments **Your money goes to your merchant account. Neolit never holds it.** An employee can connect a payment provider of yours and issue payment links against it, so a customer who buys from a page or an email pays you directly. Several providers are supported; the platform’s own billing provider is unrelated to this and is never used for your revenue. #### How the connection is done safely - The provider is connected through a card in the chat, not by dictating a key into the conversation. A secret typed into chat would sit in the history and be re-read on every subsequent turn. - The tool that starts the connection receives only the provider name. No key value passes through the model, and the fields are cleared from the browser once the connection succeeds. #### Payment link integrity A link a customer pays through must be a link the platform actually issued. This is enforced rather than requested, because the failure mode is not lying — it is paraphrasing: a long signed URL cannot survive being retyped from memory, and no amount of instruction changes that. - A truncated link is repaired by the server, which knows the real one. - An invented link is blocked outright, because there is nothing to repair. - A test checkout on a selling page must announce itself: a button that takes no money is worse than no button. - The rule is enforced in all three places a link can escape: a published site, an outgoing email, and the text of a chat reply — because what you copy is usually the text, not the card. - Your own existing payment page, hosted elsewhere, is not covered by any of this. We know nothing about it, and blocking it would be blocking the way you sold before us. --- # Trust and safety _Access, provenance, and what we refuse to fake_ ## Sessions, access and permissions `trust/permissions` · https://neolit.ai/docs#trust/permissions **How access is bounded, and what an employee can never reach.** - Your session is a host-bound, HTTP-only cookie. Cross-site request forgery is prevented by origin checking rather than by tokens you have to carry. - An employee starts with no access to anything. Every account, mailbox, channel and site sign-in is something you connected. - Stored credentials are substituted into forms by the platform. The model never sees a password, the action log records only that a saved login was used, and a missing or unknown credential produces a refusal rather than typing a placeholder into the field. - On a turn handling content fetched from the outside world, self-configuration is blocked and reading your contact database is blocked. Writing under an injection would corrupt one record; reading would export your list into the text of a turn. - Reading your contacts is capped per call and paged, so no single call can drain the database. - Text from a web page is always treated as data. Instructions found in it are not instructions. ## Provenance: measured, reported, invisible `trust/provenance` · https://neolit.ai/docs#trust/provenance **A number in Neolit always says where it came from. This is the single most load-bearing convention in the product.** - **Measured** — We saw it ourselves — our tracker recorded the visit, our run sent the message, our collector received the enquiry. - **Reported by you** — You told us. Valid, useful, and labelled differently on purpose. - **Not visible to us** — It may well have happened, but it happened somewhere we cannot see — a site on another platform, payments through a gateway we are not connected to, a channel you run by hand. The third one has its own symbol on the launch map, and it is deliberately not the same as "not started". Something invisible to us is excluded from the denominator of a completion percentage entirely, because counting it as incomplete would be a lie in the other direction. The same discipline applies to knowledge and to decisions: a fact is verified or observed, a decision is a hypothesis, tested or confirmed, a channel’s cost of entry is assumed or verified. In each case a machine can move the middle rung and only a human can set the top one. ## What we refuse to fake `trust/honesty` · https://neolit.ai/docs#trust/honesty **A short list of things the platform will not do, even when doing them would look better.** - It will not report a send it could not observe. An open composer is not proof of a message. - It will not close a goal as reached without a trace. It will stop with a reason instead. - It will not show platform telemetry it does not have. The role KPI panel declares what is measured; it does not invent numbers to fill the space. - It will not silently truncate. A capped list says it is capped; a partly-read page says how much was read; a video too long for one shot is assembled rather than trimmed. - It will not present an empty read as an empty world. "The list is empty" and "the list could not be read" are different answers, and the second one blocks the decision rather than proceeding. - It will not invent a fact from a non-answer. "I do not know" during intake stays "not known". - It will not put a price on something it cannot see. There is no cost-per-lead, because your ad spend lives in your account. ## Where your data lives `trust/data` · https://neolit.ai/docs#trust/data **What the platform stores, what it deliberately does not, and what you can take with you.** #### Yours, held by us - Conversations, memory, goals and their runs, artifacts, tables, notes and contacts. - Credentials for sites your employee signs into, encrypted in a vault. The value is substituted into the form by the platform; it is never shown to the model, never written into an action log, and never repeated in chat. - Provider keys you bring, encrypted the same way. - Files your employee produces, in object storage, reachable from the artifact that references them. #### Not stored, on purpose - Your site visitors’ raw addresses, user agents, or full URLs. The traffic counter keeps what it needs to count, not what it could collect. - Card details. Checkout is a redirect to the payment provider’s own page; there is no payment code running on our pages. - Payment provider secrets in conversation history — the connection is a form, not a message. - What you spend inside your own advertising accounts. It is not visible to us, which is why there is no cost-per-lead anywhere in the product. #### Boundaries - A project member works in the project workspace; a solo employee works in its own. That boundary is why one sees the project’s notes and contacts and the other does not. - Deleting an employee takes its chat, memory, goals, tasks and memberships. Your contacts stay — they belong to your workspace, and the employee was only the attribution on the record. - A public project page exists only while you have switched it on. Otherwise it is not served at all, rather than hidden. - Records submitted to a site your project publishes are never publicly readable — there is no public read of records, by construction. #### Taking it with you Every artifact is a file you can download. Tables export. Contacts import and export as CSV. Memory is a set of documents you can read and edit in the Memory tab. ## Interface languages `trust/languages` · https://neolit.ai/docs#trust/languages **Eleven languages, loaded one at a time.** The interface is available in English, Chinese, Spanish, French, Portuguese, German, Russian, Turkish, Indonesian, Japanese and Korean. Your language is remembered in the browser and defaults to the language of your browser on a first visit. - Only the dictionary for your language is downloaded, and only the part of it the page you opened actually uses — a marketing page does not pay for the vocabulary of the dashboard. - Switching language reloads the page so the right dictionary is fetched. - Your interface language is separate from the language your employees write in. That one follows the market of the project and your own language setting. > **Note:** These documentation pages are currently written in English only. The rest of the interface — navigation, the contents menu, and every product screen — is translated. --- # Reference _Addresses, statuses, limits, and honest gaps_ ## Address map `reference/urls` · https://neolit.ai/docs#reference/urls **Every stable URL in the product.** | Address | What is there | | --- | --- | | / | Home, with the live marketplace. | | /Employees | The marketplace storefront. | | /agent/ | Public profile of a listing. Crawlable, unique per listing. | | /hire/ | Sign up and hire that listing. | | /create | Create an employee, a team, or a project. | | /dashboard/ | Your employee. All personal tabs. | | /team/ | A team, in the same dashboard shell in team mode. | | /project/ | A project. | | /p/ | Public page of a project, when visibility is set to link. | | /pricing | Plans and token packs. | | /docs | This documentation. | | /vision | Where the product is going. | | /strategy | How the product approaches automation. | | /stack | What it is built on. | | /beta | The early beta page and the public wall. | | /agent-first | How the product is designed: you set the outcome, the employee plans the steps. | | /terms, /privacy, /refund, /security | Legal, and how to report a vulnerability. | | /docs.md | This whole documentation as one Markdown file — for reading by an agent or a script. | | /llms.txt | A short machine-readable index of the public site. | > **Note:** A slug comes from a name. Renaming an employee, team or project changes its address, so treat the name as an identifier once work has started. #### Addresses inside a page A tab, a funnel step, an opened detail and a full-screen overlay are all navigation, and each puts an entry in your browser history. Back returns you to the previous view, not off the page — leaving a project’s Settings takes you to the project, not to whatever site you were on before. Narrowing a view — a filter chip, a region, a sub-tab — refines the current entry instead of adding one, so you do not have to press Back six times to get out. A documentation article is addressable too: /docs#
/
, for example /docs#goals/evidence. That address survives a refresh, can be bookmarked, and is what support will quote at you. An address that no longer exists lands on the first article rather than on an empty screen. ## Statuses and stop reasons `reference/statuses` · https://neolit.ai/docs#reference/statuses **What each state of a goal means.** #### Goal statuses - **Active** — Scheduled and running. - **Paused** — Stopped for a named reason, waiting for a specific action. See "When a goal stops". - **Awaiting review** — A result is waiting for your decision. - **Reached** — Ended with evidence. Carries a verdict and a reason. - **Stopped** — Ended by your decision, with a reason. - **Failed** — Ended without a result, with a reason. - **Archived** — Removed from the working list. Terminal states are irreversible by design. #### Common stop reasons | Reason | Means | | --- | --- | | Budget reached | The goal ceiling is exhausted. Raise it. | | Out of funds | The wallet is empty. Top up. | | Access required | A sign-in or an account is needed on a specific platform. | | Setup required | A named setup step is missing. | | Effect needs confirming | The platform cannot verify what happened and is asking you. | | Capability missing | The outcome is not reachable with what exists. The platform proposes the nearest reachable version. | | Stalled | Three daily warnings with no movement. | | No result | Ended without a trace, rather than hanging or claiming success. | | Parent asleep | The parent goal is paused; the cascade will wake with it. | ## Limits and caps `reference/limits` · https://neolit.ai/docs#reference/limits **The boundaries you will actually meet.** | Limit | Value | | --- | --- | | Members in a team | 10 | | Clarifying questions in Start with AI | up to 3 | | Follow-ups on finished work | 3 per goal | | Criteria carried into a re-search after declining candidates | 3 | | Specialists built from scratch per goal | 1 (more when a staged plan calls for it) | | Video length in one generation | up to 60 seconds, assembled from segments | | Contacts returned per read | 25 rows plus a cursor | | Browser calls in one turn | 10, and three empty calls in a row end it earlier | | Open board cards per team member | 50 | | Auto-queued work per team | 16 cards | | Team message history loaded at once | 300 rows, then paged | | Tools in the registry | ~150, gated by role, permission and goal phase | | Connectors / catalogued API services | 37 / 371 | | Storefront listings displayed | capped, with the total and the truncation stated in the response | | Goal budget | set by you, per goal | | Project budget | set by you, stops new project-attributed work | > **Note:** Caps that hide something always say so. If a list is truncated, the interface tells you the total. ## Common questions `reference/faq` · https://neolit.ai/docs#reference/faq **Things that come up in the first week.** - **The employee says it did something. How do I check?** — Open the goal activity log for that run. Every action is there with its result, and produced files are on the Artifacts shelf with the run they came from. If the run could not observe a confirmation, it will say the step was unverified. - **My goal is paused and Resume does nothing.** — Resume only appears when resuming would actually help. If it is offered and returns the goal to the same pause, the wall is spend: the ceiling has to be raised, because spend does not go down. - **Why did it ask me before doing something obvious?** — Irreversible actions raise an approval. You can widen what it may do without asking in Guardrails. - **Why is it writing to customers in the wrong language?** — Customer-facing language comes from the project market, not from your interface language. Both are in project settings, and they are separate on purpose. - **Can two employees share the same login to a site?** — No. Sessions belong to a browser profile, and a project member browses in the project profile rather than its personal one — which is also why its sign-in state can differ from what its own dashboard shows. - **I hired the same specialist twice. Is that a mistake?** — Not necessarily. The same listing can staff several teams, and each copy is a separate worker with its own memory and goals. - **What happens to my data when I delete an employee?** — Its chat, memory, goals, tasks and memberships go with it. Your contacts stay — they belong to your workspace. - **Does closing the browser stop the work?** — No. Goals are scheduled by the platform and run without you. ## Known limitations `reference/not-yet` · https://neolit.ai/docs#reference/not-yet **Things that are deliberately absent, incomplete, or not what they might look like. Kept here so you do not discover them the expensive way.** - The storefront shows a capped slice of the full catalogue. Every listing has a public profile page and appears in the sitemap; the cap affects the storefront view only, and the response states the total. - Ad accounts are not operated. Everything around an ad — the page, the copy, the segments, the tagged links, the intake of enquiries — is done; the account itself stays with you, and so does the spend, which is why there is no cost-per-lead anywhere. - Live backend services are not deployed. A goal that needs one is rewritten into a published page plus a project table. - Reading a complex page can degrade to plain text. When it does, the run says what it could and could not see rather than filling the gap with a guess. - A messenger send performed through a browser is not automatically counted as a confirmed effect for a goal. Confirmed channel effects require a connected integration. - Coordination chat inside a project exists but its entrance is intentionally hidden. Project work is directed through goals and the feed. - Some channel toggles in onboarding are interface-only until the corresponding account is connected. - Voice has no lip-synced video counterpart, and generated video has no generated soundtrack. A brief that asks for one is told so instead of being quietly given something else. - There is no public API for third-party developers and no API keys to issue. Your employee can call anything; you cannot yet call your employee from your own code. - You cannot bring your own model. There is no model picker and no place to add a provider key for the model itself — which model runs a job is routed by the platform, and its cost is inside the ◆ price of the run. Keys you add in Apps are for services your employee calls, not for the model it thinks with. - There is no wallet, escrow or on-chain settlement. Money from your customers goes to your own merchant account with Creem, Paddle, Dodo, Polar or Lemon Squeezy; we hold no balance of yours. - Nothing self-hosts. The browser and the platform run on our infrastructure; there is no option to point either at a server of yours. - Video generation is platform-only. Images, transcription, search and scraping can run on a key of yours; video cannot. - Publishing a site usually takes the employee more than one attempt, because the checks in "What done means" run before the page is allowed out. That is the cost of the page being correct when it arrives. - The cost of entry to a platform is verified for some countries and marked as unverified for the rest. An unverified channel is ranked with the walls rather than ahead of a proven one, and it says which it is. - Making a deck is a path very few owners use. If it is not doing what you expect, that is worth telling us — the sample size is small enough that your case is data. > **Tip:** If something here blocks you, say so through Support. This list exists because the alternative — finding out mid-goal — costs more than the paragraph.