Features

Projects, not just conversations

• A project is a workspace — its own files, notes, agents, plans and history, shared live between you and the agents working in it.
• Browse your own disk. Open, read and edit files from your machine inside the app.
• A canvas beside the chat. Artifacts land somewhere you can actually look at them, at the same time as the conversation that produced them.
• Search by meaning, not just by string — across everything indexed in the project.
• Per-project embedding model, so a small project can use something fast and a large one something better.

A team, not an assistant

• Build your own agent from the UI: name it, instruct it, choose its model, give it tools.
• Agent groups. Several specialists working one goal together.
• Watch them work. Group discussions run in the open — you can read the exchange, see the artifacts as they appear, and step in.
• Milestones and convergent plans. A long discussion is synthesised into decisions and plans rather than left as a transcript.
• Autopilot. Hand over a goal and let the platform plan, execute and report — with a hard rule that it cannot claim a green result without evidence of the work.

Real coding, on your real repository

• Your working copy, in place. Agents edit the files you already have, and a build runs where the code lives — so "it compiles" is about your project, not a copy of it.
• Code intelligence. A semantic index plus a knowledge graph of your codebase, so "where do we handle expired sessions?" gets an answer even when nothing is called that.
• Language-server-grade tools. Go to definition, find references, rename — the same operations your IDE performs, available to the agent.
• Incremental indexing. A large repository indexes incrementally rather than from scratch every time.
• Git, end to end. Clone, branch, commit, push, open a pull request.
• Builds that actually build. Maven builds run in a container against the real project root, so a "it compiles" claim means it compiled.

Any model you like

• Any OpenAI-compatible endpoint. No lock-in, no house model.
• Hosted providers such as Groq and OpenRouter — add your key and go.
• Private and on-network models. An endpoint that only exists inside your network still works: the request travels over your own bridge, so the model stays where it is.
• Several providers configured at once, so switching is a dropdown, not a re-setup.
• Per-project model selection. Point one project at a fast local model and another at something stronger.

Tools, skills and integrations

• Skills — packaged capabilities (instructions plus real scripts) loaded when they're needed rather than crammed into every prompt.
• Connect your own MCP servers. Any MCP server you can reach becomes tools your agents can use.
• Integrations with OAuth. Connect a third-party service through a proper consent flow; credentials are held by the integration service, not pasted into a chat.
• A sandbox for the messy work — media conversion, scripts, one-off processing — kept separate from your project files.
• Document reading. Pull structured content out of PDFs and documents.

Research and learning (Ektist)

• Grounded answers. Citations back to the source, so you can check.
• Learn from a codebase. Point it at an unfamiliar repository and get an explanation.
• An interactive toolbox of analogies and explanations for teaching a concept, not just answering a question.

On the roadmap

• Choose where heavy work runs — on your machine or in the cloud — and have it follow your plan automatically
• A different model for each agent, not just each project
• Pick up a large codebase index where it stopped instead of starting over
• Restart a stalled run from the point it failed
• Move files between your own devices without a cloud round trip
• Watch a project's history as it happens — every step, as each agent takes it
• Diagrams and richer exports in the documents you generate
• Turn a long document into a narrated video, section by section
• More voices and languages for narration
• Work across several repositories in one project
• Connect tools that run on your own computer, not just ones with a web address
• Strip personal details out of anything before it reaches a model