#Intro

Polywise is the open-source agentic content system. You can use it as a terminal tool, a web app, or a desktop app, but the easiest way to understand it is through the app itself.

The best first impression usually comes from doing one small thing well: connect a model, open a session, ask a real question, and only then branch out into saved content, agents, and posts.

#Install

You can use Polywise from the CLI or as a web app:

npm i polywise -g

Then start the local server:

polywise start
polywise start -d

polywise start keeps the server in the foreground. polywise start -d exits immediately and leaves the server running in the background.

If you want the Web UI, open http://localhost:3072/app/ in your browser.

If you want the CLI, keep working in the terminal with polywise ... commands. The Web UI and CLI both talk to the same local service by default.

Or download the desktop application from GitHub Releases.

For a first run, Polywise mainly needs one usable model provider. Everything else can come later.

Prerequisites

#Required

• Nodejs

#Optional

• Agent Browser

• OpenCli

• Crawl4ai

• Dokobot

• Jina Reader

You do not need all of these to begin. If one provider works and one chat model answers you, that is enough to start learning the product.

#Quick Start

If you want the shortest path to confirm Polywise is working, use this loop:

#Configure

The quick-start loop above is the best way to get to first value. If you want to understand each settings page in more detail, keep going here.

#Model Providers

Start with Settings -> Model Provider.

This page is the real starting line. Pick one provider you can actually use, paste the key, enable at least one chat model, and move on. Do not try to perfect the whole provider matrix on day one.

When I checked the app, this page was already organized in a very human way: provider list on the left, credentials and enabled models on the right. That makes the job clear. You are not “configuring infrastructure.” You are just giving Polywise one brain that it can talk through.

#Local Model

Then open Settings -> Model Setting.

This page makes more sense if you read it as three jobs:

• Default Model talks to you in sessions

• Embedding Model indexes what you save

• Rerank Model helps Polywise search better

Set those first. Everything below them, like triple generation or search rewrite, can wait until you already know how you want to use the app.

The same page also shows local model status. If local generation, embedding, or rerank models are available, they appear here, and this is where you download or confirm them.

#Service Providers

Open Settings -> Service Provider when you want Polywise to get better at reading the web.

This page is really about Linkcase. It controls the local providers and fallback chain used for fetching and processing content. If your first goal is only chat, you can safely skip it. If your goal is research, clipping, and building a knowledge base, this page starts to matter early.

In practice, this is where Polywise learns how to fetch the outside world.

#IM Integration

IM Integration is optional. Leave it for later unless you already know you want external message channels tied into Polywise.

#Usage

Once one provider is connected and the default model is set, stop configuring and go use the product.

#Web UI

If you want to use Polywise in the browser, make sure the local service is running and then open http://localhost:3072/app/.

This is usually the easiest entry point because Session, Linkcase, Agent, and Posts all live in one interface.

#CLI

If you are driving Polywise from an agent or a script, the CLI is the more direct interface.

It is basically a thin wrapper over the backend API: commands are grouped by resource such as session, search, and project, with a few direct actions like save, version, and stop. By default it talks to http://localhost:3072; set POLYWISE_SERVER_URL if your server lives elsewhere.

Start with help instead of memorizing commands:

polywise -h
polywise session -h
polywise search fullTextSearch -h

For agent use, the important part is:

• use -h to expand the command tree level by level

• use --key value for simple inputs

• prefer --json for objects or arrays

• expect structured JSON output that can be piped into other tooling

Common examples:

polywise start
polywise start -d
polywise version
polywise session create --title "Daily Review"
polywise search fullTextSearch --query "vector database"
polywise save --for user --content "Key takeaway..."

When payloads get more complex, pass JSON directly:

polywise search fullTextSearch --json '{"query":"agent memory","for_types":["wiki","memory"],"enable_recall":true}'

The CLI is mainly there for agents, automations, and external tools to call the Polywise service reliably, not for long interactive use by humans.

#Ask Question

Open Session.

This is the best place to start because it gives you value immediately. On the left, the app separates Sessions, Projects, and IM. For a new user, regular sessions are the right place to begin.

Do not spend your first run on “hello.” Ask something real:

• “Summarize this workspace.”

• “Help me plan a feature.”

• “Read the repo and tell me where to start.”

• “Turn these notes into an outline.”

If the answer feels grounded and useful, your setup is already good enough.

The input bar is where Polywise starts feeling different from a generic chat app. The controls that matter most are:

• model

• effort

• mode

• audit

• submit style

The mode selector is especially important:

• Normal is everyday work

• Plan is for when you want structure first

• Plan-Exec is for when you want structure and momentum together

Two shortcuts are worth learning early:

@ brings in context like agents and files. It is the moment a session stops being abstract and starts being grounded in your workspace.

/ brings in tools and skills. It is where conversation starts feeling less like “answer this” and more like “work this way.”

#Capture Contents

Once a session makes you think, “I wish I could just feed this page into the workspace,” move to Linkcase.

Linkcase is not just a bookmarks list. It feels more like an intake desk for web material. On the left you browse links, on the right you read the captured content, and at the top the two key actions are visible right away:

• Fetch

• Extract

The beginner flow is simple:

1. add one link

2. fetch it

3. inspect the result

4. extract it

Fetch gets the page into Polywise. Extract turns it into something the rest of the system can use better. That difference is worth understanding early.

#Chat with Agents and Groups

When you notice yourself repeating the same style of instruction, stop repeating yourself and make an Agent.

That is the right time to use the Agent page. Not before.

#Agent Session

Agents are best when they are narrow and easy to trust. Good first agents are things like a repo guide, a writing partner, a research helper, or a code reviewer.

You do not need a perfect agent system on day one. You need one agent with a clear job.

#Agent Contents

The Agent page is where repeated working style becomes reusable structure. Prompt, memory, skills, tools, and linked content all start living in one place instead of being retyped in every chat.

This is the point where Polywise starts compounding. A good agent saves you from re-explaining yourself.

#Agents Group

Groups are powerful, but they are usually a second step. Start with one good agent. Add groups only when you genuinely want different agents to play different roles.

That sequence matters. One clear agent teaches you more than an early multi-agent setup.

#Write Posts

When something should live longer than a chat reply, save it as a Post.

The Post page already hints at the intended rhythm: Wiki, Memory, and User are right at the top, alongside search and a new-post action. It feels less like a publishing system and more like a place where finished thoughts go to settle.

That is the shift that matters:

chat is for motion
posts are for keeping

#Why Polywise

When knowledge and experience become less critical, from where does human value derive? How is human uniqueness manifested?

It stems from the "weight" of one's thinking—specifically, from the unique architecture of each individual's neural networks. Redefining human value: in the era of AI, human worth lies in the plasticity of one's intelligence—that is, in how one leverages AI to construct a personal digital avatar.

As long as the concept of private ownership persists, the capacity for human individuality retains its value, serving as a unique and precious personal asset. However, these capabilities must be cultivated and crystallized through sustained interaction with AI. Polywise integrates the user and the AI ​​into a single, evolving, and iterative intelligent entity—thereby amplifying human value, rather than replacing it.

Polywise is also dedicated to addressing the issues of the "knowledge explosion" and subsequent information overload characteristic of the AI ​​era. By leveraging AI's powerful inductive capabilities to handle "post-thinking"—the process of synthesizing and distilling information—it frees up human cognitive energy for matters of greater importance.