> ## Documentation Index
> Fetch the complete documentation index at: https://docs.effectiveai.app/llms.txt
> Use this file to discover all available pages before exploring further.

# Key concepts

> What each part of the Effective app is for and when to use it: chats, outcomes, projects, ContextBase, Vault, agents, skills, apps, procedures, records, assets, and data sources.

This page describes key concepts that are helpful for using Effective.

## Chats and Outcomes

### Chats

**Chats** are where you work with the agent: ask, research, draft, and analyze. You can share a
chat with other users, groups, or your team. Chats started within a [project](#projects) are not
accessible outside it, and you can restrict one further to just you or specific people using the
sharing icon in the chat box (a lock when the chat is private).

* **Use it when:** you want an answer or a draft now and will steer it as you go.

### Outcomes

**Outcomes** are a kind of chat with a goal: the agent keeps working until it's done, checking in
when it needs your input. Each outcome is driven by a Captain: an agent that breaks the work down
and delegates it, much like a program manager.

The Captain keeps going after you close the chat: it reviews the outcome once a day, wakes up when
something changes (a reply, a finished task, a new message), and can set up repeating checks, such
as a daily look for new filings. That's why outcomes work well for work that needs tracking over
time. Its page shows the goal, the latest update, questions waiting on you, outputs (documents,
records, and links), and a history of activity.

To start one, turn on **Outcome** in the chat box, beside **+**. When you start from the chat page
rather than a project's home page, also pick the project the outcome belongs to.

* **Use it when:** the work has several steps, takes days, or needs ongoing tracking, and seeing
  progress is important.

> [!TIP]
>
> Use a chat when you're driving; use an outcome when you want the agent to drive to a result. If
> unsure, use a chat.

## Projects

**Projects** are used for organizing work and setting access boundaries. By default, resources
created in a project are not accessible outside it. Most of them can be given broader access by
their creator; chats are a notable exception and always stay inside their project.

**When to start a project.** For most work, you don't need one: just chat with the agent. Start a
project when you want the agent to work with specific context or knowledge you share with others,
such as a client's files, your team's skills and procedures, or a ContextBase everyone draws on.

> [!NOTE]
>
> Projects used to be called Mission Controls. You may still see that name while everyone moves to
> [the new layout](https://docs.effectiveai.app/concepts/new-layout.md), and the API still uses it.

The Projects page lists the projects you can see, with a description, assets, people, and recent
activity for each. Create a project there, or pin one to keep it in the sidebar. A project's home
page has a chat box for starting a chat or an outcome in the project, the project's chats, and a
panel with its assets, apps, skills, procedures, and newsletters.

Project admins control who has access. The creator is an admin by default. Members and settings
are at the top of the project's home page.

Projects also decide which skills, apps, and procedures are in play. Install one from its catalog
and it's available to everyone working there, within their access. New chats pick up installed
skills automatically.

Each project draws its background knowledge from one or more ContextBases. Start a fresh one, or
connect one you already have, such as your team's shared ContextBase, so several projects can share
the same knowledge.

* **Use it when:** you're working on something sensitive and want to restrict access to a specific
  set of people.
* **Use it when:** a team needs the same skills, apps, and procedures on hand without setting them
  up in every chat.

### ContextBase

**ContextBase** stores the agent's context for a project: decisions, guidelines, definitions,
and how-tos. It should be mostly text and markdown files. Think of it as a special kind
of vault whose files are already in the agent's hands when a chat starts, so it can use them right
away.

It works best when actively curated: keep it current and trim what's stale. When the agent saves
something to ContextBase, it shows you the change first and only publishes once you approve. The
system can optionally require specific people to approve changes.

* **Use it when:** it's written knowledge the agent should always have on hand. For notes and
  guidance, prefer it over the project vault.
* **Use the project vault instead when:** the files are large or aren't text, such as big
  datasets, spreadsheets, or scanned PDFs. A large ContextBase makes every chat in the project
  slower to start.
* **Try:** "Save our decision on the new territory definitions to ContextBase." or "What does our
  ContextBase say about appetite for coastal properties?"

## Vault

**Vault** is where files live. Files are also called artifacts. Choose a vault by who should see
the file.

* **Personal:** only you can see it. Use it for drafts and scratch files.
* **Team:** everyone in your organization can see it. Use it for org-wide files. It's read-only
  inside a project; to add or change files, start a chat outside any project.
* **Library:** reference documents Effective provides, such as public rate and form filings from
  SERFF. You can read them but not write to them.
* **Project vault:** files for one project, visible to its members. Also see
  [ContextBase](#contextbase).

**Try:** "Save this spreadsheet to the project vault under reports/." or "Find the latest
homeowners filing for this carrier in the Library."

## Agents and Skills

### Agents

**Agents** are AI workers with a job. A general agent runs every chat. You can also make focused
agents with fixed instructions for one job, and anyone in the project can pick them from the agent
dropdown in the chat box. There are two ways to make one:

* **In ContextBase:** ask the agent to add one to the project's ContextBase. It's a short
  instructions file, so it's easy to review and change. By default it reads and answers, without
  running code or editing files.
* **As an app:** ask in chat for an agent app. Choose this when the agent needs its own tools,
  saved data, or connections to other systems (see [Apps](#apps)).
* **Settings:** either kind can be allowed to run code. ContextBase agents can also offer starter
  prompts, and app agents can be set to use a specific model.
* **Use it when:** you want a dedicated chat that sticks to one job, such as a guided intake for
  people who shouldn't need to know which skill to use.
* **Try:** "Add an agent to our ContextBase that reviews broker submissions against our appetite
  guide."

### Skills

**Skills** are reusable know-how any agent can pick up: the steps, standards, and even scripts for
one kind of task. They're the most common way to teach the agent something, and they can run code.

* **Use it when:** you've explained the same steps more than twice, or you keep pointing the agent
  at the same instructions file in the vault. Start here if you're unsure.
* **Try:** "/\<skill-name> on the attached file" or "Turn what we just did into a skill for
  this project."

> [!TIP]
>
> A skill adds to the everyday agent, which keeps everything else it can do, including running code.
> An agent replaces it with a narrower one that sticks to one job. So start with a skill, and make
> an agent only when you want to narrow things down.

## Apps

**Apps** are tools with their own screens, data, and integrations. You build one by asking in chat.

Each app comes with:

* **Its own database and file storage**, so data is kept between chats.
* **Secrets** for connecting to outside services.
* **Access to Effective data**, such as filings and records.
* **API keys**, so outside systems can call the app.

Apps don't run on a schedule by themselves; use a [procedure](#procedures) for that.

Every app published to a project also appears in the agent dropdown. Picking it starts a chat with
the app's own agent, which follows the app's instructions and uses only the app's tools. You don't
need to pick it to use those tools: the everyday agent in that project can already use them.

* **Use it when:** people need a screen to click through, data has to be kept outside of chats, or
  the work connects to another system.
* **Try:** "Build me an app where underwriters log submissions and see a status board."

## Procedures

**Procedures** are fixed workflows that run the same steps every time, with a history of every
run. Each step can be a bit of code, an agent, or a person: a person step pauses the run until
someone reviews it or fills something in. Procedures can be tuned to save cost, since not every
step needs an agent and each agent step can use a preconfigured model.

A procedure's page has:

* **Procedure, Outline, and Graph:** the steps, as a document or a diagram.
* **Runs:** every run with its inputs, results, and status. Start a run here, or have the agent run
  it with you.
* **Triggers:** start runs automatically on a schedule, when a file lands in a Vault folder, or
  when an event happens.
* **Secrets:** for connecting to outside services.

To make one, describe the process in chat, or do it once with the agent, and ask it to turn that
into a procedure. The agent writes and tests the steps and publishes when you say so.

* **Use it when:** a process must be repeatable and auditable, such as monthly reporting or intake
  checks. If the agent can use judgment on the steps, a skill is lighter.
* **Try:** "Turn what we just did into a procedure." or "Run the monthly rate-monitor procedure for
  Q3." or "Make this checklist a procedure that runs every Monday."

## Records

**Records** are the structured things your organization keeps track of, such as products, filings,
and accounts. Each kind of record (a record type) has its own fields, and people and agents read
and edit the same records.

Records aren't kept inside a project. Find them under Records in the left sidebar, which lists the
record types you've pinned or viewed recently, plus All records. From there you can:

* **Browse** each type as a table with search, filters, and saved views, kept for yourself or
  shared with everyone.
* **Open a record** to see its overview, documents, related records, and an activity history of
  every change and comment. Pin a record to keep it under Pinned in the sidebar.
* **Request approvals** from people or groups, narrow who can see a record, and see the outcomes
  working on it.
* **Add record types:** install built-in types from the catalog, or create a custom type, for
  example by starting from a spreadsheet.

The agent can do the same from chat. Ask it to look up, create or update records, set up a new
record type, or import rows from a spreadsheet.

* **Use it when:** you track many of the same kind of thing and want fields, filters, and history,
  not a pile of documents.
* **Try:** "Create a record for each carrier in this spreadsheet." or "Set up a record type for
  surety bonds with the obligee, bond amount, and expiry date." or "@\[record name] what changed
  since the last filing?"

## Assets

**Assets** are files with extra labels: the project they're published to, what kind of deliverable
they are (report, tracker, presentation, or a link to an outside resource), and any tags. Some are kept up to date by a procedure. Publishing turns a working file into something the
team can find, filter, and @-mention.

* **Use it when:** a file is done and others should rely on it. Drafts and working files stay in
  the Vault.
* **Try:** "Publish this comparison as a tracker asset tagged Q4." or "@\[asset name] update the
  Texas numbers."

## Data sources

**Data sources** are outside datasets the agent can look things up in, such as:

* SERFF filings
* EDGAR
* Legal records
* Regulatory documents
* NAIC statements

There are more, and new data sources added to the Effective platform show up too. Your
organization picks which ones are on by default, and you can change them for a chat from the +
button in the chat box.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.