Common questions.

Annsa is project management and customer feedback software for founders and small teams working with AI agents. Choose what to build from your goals and customer feedback, give every agent one shared plan, and learn from what ships.

Founders running a business with a team of AI agents. Reach for Annsa when you're carrying the plan between chats, losing track of what's done and deciding every next step yourself.

No. Annsa ranks the work and shows the evidence behind it. A person makes the call, and the reason stays with the work so the next agent can read it.

A feedback tool stops at the dashboard. A roadmap tool stops at the plan. A project tracker holds the tickets, not the reason for them. Annsa carries the call through: the evidence behind a priority, the spec an agent builds from, what you decided, and what happened after it shipped, in one place every agent can read.

Claude Code, Cursor, Codex and Grok, over remote MCP at https://app.annsa.ai/mcp. You sign in with OAuth in the browser and there is nothing to install. Each agent keeps its own connection and reads the same priorities, specs and decisions.

Most days start with Annsa's Radar: what's rising, what shipped and what went quiet. Needs You holds the calls your agents brought you. Your agents claim the next priority, verify each Done When line and ship, and you send the note to the customers who asked.

If you run one agent and a to-do list works, you don't need Annsa yet. It earns its keep once more than one agent is building and customer requests arrive faster than you can track them. Try Annsa is free for 100 signals, so you can test it on your own feedback.

Annsa brings your priorities, customer requests, plans and agent progress into one place. Keep the agents you already use, your analytics and your code host. Connect agents through MCP so they can read the plan and record their work.

Yes. Import up to 10,000 rows (50 MB) from a CSV export, then connect Slack and Intercom for what comes next. Annsa doesn't import directly from other tools today, so votes and history stay in the old tool unless you export them.

Customer feedback, your own ideas, a roadmap you already have, and what your agents find while they build. It all lands in one list. Each piece is placed against the priorities you already have, or starts a new one.

Your bets come first, in your order. Within each bet, what a person marked broken (P0 or P1) comes first, then what customers asked for, then ideas. Customer evidence ranks by how many companies asked, then revenue and urgency, or you can rank the whole list for one goal, like revenue. Agent findings rank by severity, P0 to P3: an agent proposes it, and your severity always wins over Annsa's. Different words for the same problem become one priority, and unrelated signals stay apart. Each priority carries who asked and what they said.

Every priority shows why it ranks where it does and what it beat. Change the lens, split it, rename it or move a row. When you move one, Annsa learns from it.

A bet is a business goal you want the work to support. Put your bets in order and group priorities beneath them, so you and your agents can see what comes first.

Into the same list, beside what customers said, with a proposed severity. An agent checks whether the problem is already there before filing. What an agent proposes stays a proposal until a person places it.

Open the customer and you see everything they've asked for, the priorities it fed, and the updates they were sent. Ask can bring up the same account beside an answer.

Radar shows what changed, for the day or the week: what's at risk, what's worth most and what's growing, with each company counted once. Needs You holds what's waiting on you: questions from agents and shipped work that came back. Anything urgent comes as an alert, once a day.

No. With Annsa, feedback from Slack and Intercom flows in and is grouped into priorities automatically, in each customer's own words. There's no taxonomy to set up. If two priorities should be one, merge them, or correct a title, and your call sticks.

Yes. Annsa groups new feedback as it arrives and the ranking moves with it: more companies asking moves a priority up. Your bets set the order at the top, and anything a person sets, like a severity, always wins over what Annsa computed.

Yes. Create an NPS, satisfaction (CSAT), CES, product-market fit, approval or open survey in Annsa and show it in your product. Each survey has its own results dashboard, where you can review the responses.

Yes, once revenue is in. Import it or set it on each customer, and Annsa shows what every customer pays, lets you search and filter customers by revenue, and weighs revenue into the ranking. You can also rank the whole list for revenue, so your highest-paying accounts' requests rise.

Yes. In Annsa, bets are your goals: set them in order, and priorities rank inside each one. You can also rank the whole list for a single goal, such as revenue, user growth or retention.

Every Annsa priority shows the quotes and companies behind it, so you can check the grouping against what customers said. If it's wrong, merge it, correct the title or set the severity yourself. A person makes the call; Annsa ranks and suggests.

It asks when it connects. Annsa hands it skills to save in its own skills folder: how to work with Annsa, how to write its part of a spec, and how to ask a person. Nothing to install, and every agent gets the same ones.

The spec: what to build, why, who asked, the files to touch and Done When. With it come what a person already decided and what the agent may settle on its own.

No, but it helps. Connected, your agent gets your repo's context with each spec, and a merged pull request that names the priority links to it. It ships once every Done When line is checked. Annsa works without it.

An agent claims a priority before it starts, and a claimed priority is refused to anyone else. When it stops, it hands off with what's true now and the next step, or releases it with what it ruled out.

Connected with your own sign-in, your agent acts as you and can do anything you can. Give an agent its own credential instead (an owner does this in Settings → Integrations → Agents) and it can file findings, claim work, write its part of a spec, record progress, verify and ship, while signing, answering and telling customers stay with a person.

The agent asks instead of guessing. The question lands in Needs You with the options, and the agent carries on with other work. You answer once, from Needs You or the terminal, and the answer lands on the priority and its spec.

No. Answer once and the decision, with its reason, stays on the priority and its spec, where every agent reads it over MCP. Widen it into a principle and every agent learns it. Decide once.

Yes. Claude Code, Cursor, Codex and Grok read the same ranked list and specs over MCP that your team sees in Annsa. Each agent holds one priority at a time and brings you the calls that are yours: scope, customers, a principle, a real choice or security.

Give every agent the same spec. In Annsa each spec carries the customer's words, the files to touch and Done When lines. Your agent verifies each line and leaves a receipt, and brings real decisions to you instead of guessing.

Yes. Put an Annsa-Spec line or #N in the pull request and Annsa links it to the priority and the customers behind it. When the work reaches your live branch and every Done When line has a receipt, Annsa marks it shipped and drafts a note to each person who asked.

Every spec has Done When lines. Before an agent ships, it records a receipt for each line: a test, a URL or a thread you can follow. A line it couldn't check stays unchecked, and the agent says so.

When it ships, Annsa drafts a note to every customer behind the priority, one message per person however much shipped. You review it and send it, unless you've turned on automatic sending in your account settings. It's off by default.

Cut a release for a period and you get everything shipped since the last one, in the priorities' own words, ready to paste. Share Back stays a separate step.

Ask it. Annsa shows whether the signals went quiet after it shipped and whether the metric moved, with the quotes behind it. If new signals arrive on shipped work, it comes back to you in Needs You.

What shipped, what you corrected, what you dismissed and what you decided, with the reason. Before the next spec starts in the same area, the last outcome is right there.

When an agent releases or hands off work, it records what it ruled out. When it ships, it records what the next spec should know. Both stay on the priority for the next agent to read.

Yes. Annsa's Ask answers questions about your customers and your work, with the quotes behind each answer. Ask it in the app, in Slack or from your agent over MCP. It answers from your own evidence, not the open web.

Yes. Annsa keeps your priorities, specs, decisions and customer evidence in one place. People ask it in the app or Slack; agents read it over MCP. Answers you save become rules every agent reads, so a decision made once reaches every agent.

Yes. Every Annsa priority keeps who asked, their exact words and their companies. The spec, the pull request, the Done When receipts and the note to customers all sit on that same priority, so you can follow one feature from first request to shipped.

Run your next three decisions through Annsa and compare. Annsa shows what shipped each week, who asked for it and the receipts for each Done When line. It doesn't measure team velocity, so judge it by how often an agent had to stop and ask you, and how long each call took.

The signal allowance. Every plan includes every feature. Try Annsa gives you 100 signals once, with your own work. Annsa is $19 per person a month with 500 signals per person; Annsa Plus is $39 with 1,500. Allowances pool across the team: five people on Annsa share 2,500 signals, and five on Annsa Plus share 7,500.

No. Try Annsa needs no card and never charges automatically. Its 100 signals are once only. Annsa and Annsa Plus need a card; cancel anytime.

One distinct piece of feedback or evidence: a Slack message, a widget or survey response, an Intercom conversation, a CSV row, a manual entry. A call transcript can hold several. Duplicates are removed on import and don't count.

Your existing work and agent access stay available. New Annsa-funded signal processing pauses until your allowance renews or you upgrade. Nothing is silently dropped, and there are no automatic overage charges. You can also buy a one-time top-up from Settings → Billing. Held items process oldest-first, immediately when you upgrade or top up, or when the allowance renews.

A person who creates priorities, makes decisions and directs work in Annsa. Connected agents and customers giving feedback aren't seats; agents are paid through their own provider.

Yes. Upgrade or downgrade any time in Settings, Billing. Upgrades take effect immediately and are prorated. Downgrades start at your next billing period.

When your paid plan ends, we keep your data for 30 days. Reactivate in that window and everything is where you left it. After that it's permanently deleted.

Data is stored on encrypted infrastructure with Supabase (Postgres). All connections use TLS. Backups are encrypted at rest.

Only the people in your workspace, with the roles you give them. Sign-in supports two-factor authentication with an authenticator app, optional for everyone on the team. Annsa staff don't look at your workspace data unless you ask for support or it's needed to keep the service running. Your data is hosted on Supabase, encrypted at rest and in transit, and never used to train AI models.

No. Annsa reads a short profile of your repository: tech stack, structure, rules files like CLAUDE.md and recent pull requests. It does not clone, store or index your full codebase. Read access, scoped to what your agent needs. Annsa never changes your code, though it can open a GitHub issue from a priority.

No. Annsa uses AI for classification, judgments, Ask and the spec drafts you ask for, but customer data is never used to train models. Your data stays within the processing pipeline and is not shared with third parties for training purposes.

Annsa reads a short profile of your repository, not your full codebase. It strips personal details before it groups and ranks feedback, encrypts data in transit and at rest, and never uses your data to train models. Only your team, with the roles you set, can see it.

Add the remote MCP server at https://app.annsa.ai/mcp. One URL, sign in once in the browser, nothing to install. Connect Claude Code, Cursor, Codex or Grok so your agent can read priorities and the spec for a job. Add customer feedback or your existing plans, and connect GitHub when you want repository context.

Connect Annsa to Cursor over MCP. From inside Cursor, annsa.priorities fetches the ranked list, annsa.spec pulls the spec, with its files to touch, annsa.ask searches the evidence, and annsa.work records the work, from claiming a priority to shipping it.

Connect Annsa to Claude Code over MCP. Claude Code picks up a priority, reads the spec and the decisions behind it, and asks you when a call is yours. Annsa holds what's worth building and why; Claude Code builds it.

Annsa's remote MCP server gives every agent the same direction: eight tools (annsa.priorities, annsa.spec, annsa.ask, annsa.work, annsa.file, annsa.decide, annsa.board and annsa.share) plus the skills an agent needs to use them. Connect at https://app.annsa.ai/mcp, with nothing to install. It works in Claude Code, Cursor, Codex and Grok.

It gives your agents the evidence the spec depends on. Spec-driven development means writing the spec before the code, so the build follows intent. In Annsa, you, your agent over MCP, or Ask on request writes the spec from the quotes, people and findings on it, and every agent reads the same spec over MCP. You keep the call. More at /product-requirements-document.

With Annsa, you, your agent over MCP, or Ask on request writes the spec from customer evidence: what to build, why, who asked, the files to touch and Done When. Signals are ranked into priorities first, so every spec starts from what customers said. Claude Code, Cursor, Codex and Grok all read and write it over MCP.

Most teams rely on meetings, spreadsheets or gut feel. Annsa puts customer evidence, your ideas and agent findings in one ranked list, with the evidence behind every row. The team reviews the list, a person makes the call, and the reason stays with the work.

Start with your bets, in your order. Within each, put what a person marked broken (P0 or P1) first, then what customers asked for, then ideas. Then rank by how many companies asked, revenue and urgency, or weight the list for your current goal: revenue growth, retention, delight, bug fixes, new features or user growth. Every rank shows the customers and revenue behind it, so the order holds up without a meeting.

Give your customers a price (customer name and what they pay) and Annsa scores every priority by revenue impact alongside urgency. The figure is yours, not a guess: Annsa reads the prices you supply and never invents one. Set the Priority Engine to Revenue Growth and the list re-ranks to surface what the paying customers are asking for.

Annsa connects customer feedback to the work your agents do. Bring requests into one list, see who asked and choose which jobs matter to your business. You, your agent or Ask writes the spec. Try Annsa includes 100 signals once, with no card.