Why I built Talos

I'm Lorenzo Daniel Danilov, and I lead Vascend Technologies, an Italian AI lab.

I created Talos because I found existing agent harnesses too restrictive for the way I wanted to work, especially when it came to customization. I wanted to shape the tools, workflows and context management around the task, with control over how the agent operates.

After months of research, I introduced a new approach to context engineering in Talos: epoch-based context engineering, implemented through Context Fabric and Epoch–Lease–Lens. My aim is to give developers a harness they can understand, adapt and build on.

Bring your next bug, refactor or investigation to Talos. Install it, choose your model and put its context controls to the test on your own project.

I'm Italian and only 22 years old, but I want to start contributing to AI research now. I'm driven by a passion for understanding, experimenting and turning ideas into tools that people can use. I founded Vascend Technologies to put that passion into practice: to learn, share what I discover and help Europe develop its own technology through free, open and accessible research.

Each project has been a step in my research journey, from mid-2025 to September 2026: about 15 months of study, experimentation and development. I apologize in advance for any bugs you may encounter. I have focused primarily on the core functionality, and some details still need work. I hope you will understand that choice and, if you find the project useful, help support it through feedback, bug reports or contributions.

Through these projects, I also want to share a personal conviction and an invitation to anyone with an idea they want to bring to life:

“Have the ambition to create. Those who never try to build their own future end up depending on the one built by others.”

Contact: LinkedIn · Instagram @lorenzo.danilov · [email protected]

Give your coding agent a mission. Keep the controls. Talos combines an extensible agent runtime with Context Fabric: a system that tracks the current objective, gives temporary focus an expiry and lets you inspect how context is assembled.

Choose the model. Shape the workflow. Pin what matters. Carry the same engine into your scripts and applications.

Created by Lorenzo Daniel Danilov at Vascend Technologies, an Italian AI lab. Talos also powers Vascend Horizon and runs independently as a standalone CLI.

Quick start

Built with ambition. Still evolving. Talos is not perfect yet and you may encounter bugs. We apologize in advance for any issues and will continue to maintain it with updates, fixes and improvements. Follow the Talos changelog for release-by-release details, or contact [email protected] to report a problem.

Put Talos to work on your next real task. With Node.js 20 or newer, run:

npm install -g @vascend/talos
talos

You can also use bun add -g @vascend/talos, pnpm add -g @vascend/talos, or yarn global add @vascend/talos (Yarn Classic). The package includes the compiled CLI and SDK; GitHub access and a local build are not required.

On macOS and Linux, the installer uses a writable user directory:

curl -fsSL https://vascend.it/install | bash

On Windows, run in PowerShell:

irm https://vascend.it/install.ps1 | iex

Both installers automatically install a verified Node.js LTS runtime with npm when a compatible installation is unavailable. No administrator privileges are needed. Run talos to check for newer stable versions; the startup prompt shows current version → new version and offers Skip for now or Update now.

Talos checks npm for new stable releases, downloads from Vascend with an official npm fallback, and verifies the registry signature and SHA-512 integrity before installing with lifecycle scripts disabled. The initial installer command still trusts the HTTPS site serving the script.

The installers add talos to your user PATH. On Windows it is available in the current PowerShell window; on Bash/Zsh, open a new terminal or use the activation command printed by the installer. No administrator rights or changes to PowerShell execution policy are required.

On first launch, follow the guided Vascend account sign-in. Use /login to connect your provider and /models to choose a model. Try a concrete task:

Find the cause of the failing tests in this repository, implement a fix,
and verify it. Preserve the existing public API.

Then open /context explain to inspect the mission, active focus and context budget. See what your harness is doing while you work.

For a source checkout, install Git and Bun, then use a GitHub account with repository access:

git clone https://github.com/VascendTechnologies/vascend-talos.git
cd vascend-talos
bun install --frozen-lockfile
bun run install:cli

For development, run bun run dev from the repository. For a single task:

bun run src/index.ts -p "Summarize this repository"

To update a clean checkout and rebuild the global commands:

git pull --ff-only
bun install --frozen-lockfile
bun run install:cli

Full configuration and API key examples: CLI reference (Italian).

Talos inside Horizon

Prefer a desktop interface? Talos is also available inside Vascend Horizon. Work with the agent from Horizon's interface, or install the standalone CLI to use Talos in your terminal.

Explore Horizon →

Why Talos

Choose Talos when the way your agent works matters as much as the model it uses.

| What you want to improve | The Talos advantage | | --- | --- | | Keep long tasks on mission | Epochs preserve the active objective through follow-ups. A Goal Contract records corrections, constraints and success criteria. | | Coordinate complex missions | A persistent work queue, fresh execution sessions per work item, configurable verification gates and retry tracking make extended work observable and resumable. | | Decide what stays in focus | Expiring leases remove old focus terms; explicit pins keep the terms you choose. Inspect the current decisions with /context explain. | | Make the agent fit your process | Combine project instructions, skills, MCP tools, hooks and extensions. Select a working profile for debugging, research, security and more. | | Use the model that fits the task | Choose Anthropic, OpenAI-compatible providers or local Ollama models from the same runtime. | | Turn your workflow into a product | Use Talos interactively, automate it from the CLI, or embed the engine through the TypeScript SDK, JSONL RPC or Horizon Engine. | | Keep working while the agent works | Draft your next message while questions wait above the prompt. Open full tool output on demand and resume saved sessions. |

Comparing your next coding agent?

Claude Code offers skills, hooks, MCP and other extensions, and OpenCode supports custom tools and an SDK. The reason to try Talos is its particular combination: explicit mission epochs, expiring focus, selectable context recipes and an inspectable receipt, integrated into the engine you can also embed.

Put context control on your comparison checklist: can you inspect the current mission, see why a working profile was selected, pin a focus term and deliberately start a fresh epoch? In Talos, those are built-in controls you can try immediately.

Long tasks. Complex missions. Intelligent control.

Talos is built to carry a mission through many steps. It combines persistent task state, project memory, context checkpoints and a work runner for queued missions. Each queued work item receives its own brief and execution session, with progress, evidence and failures recorded along the way.

Intelligent control means reassessing the situation as work progresses: the agent can use current evidence, goal revisions and project state to decide its next step. The work runner tracks completed, retrying and blocked items, keeps active work leases alive and applies an external verification gate when one is configured. You can inspect the state and set work limits, deadlines or cancellation.

24 consecutive days — the longest continuous run recorded internally, as reported by Lorenzo Daniel Danilov at Vascend Technologies AI Lab. This is a reported internal duration record, not a guaranteed run length or a measure of task success. Actual duration depends on the workload, model/provider availability, infrastructure and configured limits.

Explore the work runner, context lifecycle and CLI reference to see how long missions are controlled.

Epoch-based context engineering

Open the full-resolution infographic

A map of the context engine: mission control, scoped sources, context compilation, execution and feedback. Receipt, compaction and context lanes support the turn lifecycle.

An epoch is a phase of work organized around a specific objective. Context Fabric tracks that objective across turns and builds the working context needed to pursue it.

| Concept | How it works | | --- | --- | | Epoch — the objective | A follow-up such as “continue” keeps the current mission. When Talos detects a new task, it opens a new epoch. A versioned Goal Contract tracks the objective, corrections, constraints and success criteria. | | Lease — the lifetime of focus | Focus terms have an explicit lifetime: mission terms last for the epoch, while details from a turn or working mode expire after a few turns unless renewed. Explicitly pinned terms persist across epochs in the same session. | | Lens — the working profile | Profiles such as debug, research and security set retrieval priorities, ranking weights, context budgets and evidence requirements. Choose one with /vibe, or let auto route the task. |

On each turn, Talos combines the current request, mission, goal revisions and active focus terms into a retrieval query. The Context Window Compiler retrieves relevant project memory, decisions and evidence, ranks and filters them, and assembles a Prompt Pack within the selected context budget. Epochs organize this working context alongside the saved conversation history and persistent project memory.

For example, “Fix the login bug” starts a mission. “Continue” keeps that mission; “Also handle login cancellation” refines it. “New task: review the deployment configuration” opens a new epoch, dropping the previous epoch's unpinned focus terms. Explicit pins remain, and stored information can be retrieved again when relevant.

Use /context or /context explain to inspect the active epoch, focus terms, routing reasons and context budget. Use /context pin <term or path> to retain a focus term and /context unpin <term or path> to release it. /context reset starts a new epoch on the next turn while preserving explicit pins.

See Context Fabric for the full lifecycle, persistence rules and implementation details.

Measured context control

Our five-scenario, deterministic offline context benchmark, rerun on September 11, 2026, covers follow-ups, task changes, session resumption, repository isolation and profile selection. It exercises Talos's context compiler against a documented local retrieval baseline.

| Metric in this fixture suite | Talos Context Fabric | Local retrieval proxy | | --- | ---: | ---: | | Precision of selected context | 100.0% | 66.7% | | Continuity across follow-ups and resumption | 100.0% | 50.0% | | Leakage of forbidden stale items — lower is better | 0.0% | 52.8% | | Reported context token count — total | 377 | 512 |

These are internal fixture results against the repository's cursor-style-proxy, not measurements of the Cursor product or a live coding comparison with competing agents. They measure context selection in this suite, not coding success, latency or your API bill. The value is reproducibility: inspect the full report, raw results and methodology, or run bun run bench:context from a source checkout.

Keep your place in the conversation

Keep writing while the agent asks a question. Questions wait above the prompt. Open one when you are ready, choose an option or select Other to write your own answer. Your main prompt and answer drafts remain separate.

| Action | Shortcut | | --- | --- | | Open a pending question | Shift+← | | Submit an answer | Enter | | Return to the main prompt and keep the answer draft | Alt+↓ or Esc | | Skip the current question | Ctrl+] | | Read complete tool output | Ctrl+R | | Manage queued messages | Alt+Q or /queue |

Loaded skills have a compact activity entry; the full content stays in the operation details:

• Explored
  └ Read SKILL.md (vascend-ops skill)

Use /language to choose English, Italian, Spanish or German. The choice is saved between launches. /language system restores automatic detection; TALOS_LANGUAGE provides a process-level override.

CLI & SDK

| Entry point | Example | Use | | --- | --- | --- | | Interactive terminal | talos | Work alongside the agent. | | One-shot execution | talos -p "Explain this project" | Scripts, pipes and individual tasks; add --json for events. | | RPC | talos --rpc | Connect a host over stdin/stdout using JSONL. | | TypeScript SDK | import { bootstrap, runTurn } from "@vascend/talos" | Embed the agent loop in a process. | | Horizon Engine | HorizonEngine.create(...) | Integrate the headless engine with an application. |

The SDK import is the package entry point after building and linking or installing the repository. See the SDK exports and architecture.

Everyday commands

| Command | Purpose | | --- | --- | | /help | Browse available commands. | | /login · /models | Configure provider access and select a model. | | /new · /resume | Start a conversation or reopen a saved one. | | /context · /usage | Inspect context and provider usage. | | /todo · /collaboratori | Inspect the plan or explicitly start collaborators. | | /queue · /language | Manage pending messages and the interface language. |

Providers and extensions

Use Anthropic, OpenAI, OpenRouter, Mistral, DeepSeek, xAI, Together, MiniMax or Ollama, or configure a compatible endpoint. Available models and authentication methods depend on the provider and your account. See the provider catalog.

• Project instructions: define working rules in AGENTS.md and SYSTEM.md.
• Skills: load reusable instructions from SKILL.md, including /skill:name invocations.
• MCP: connect external tools through the shared tool protocol.
• Extensions: add tools, commands, hooks and templates to the runtime.

The package declares no production npm dependencies. Optional integrations and desktop control can require additional system programs.

Platforms

| Platform | CLI | Desktop control | | --- | --- | --- | | Windows | Supported | Standalone backend included. | | macOS | Supported | Requires cliclick and Accessibility / Screen Recording permissions. | | Linux | Supported | X11 requires xdotool and ImageMagick. Global Wayland control is not supported. |

Desktop control requires separate consent, including when automatic tool approvals are enabled. See Computer Use for setup and limitations.

Documentation

| Guide | Contents | | --- | --- | | Documentation index | Find the right guide. | | CLI reference | Installation, commands, configuration, queues and providers. | | Architecture | Runtime modules and integration boundaries. | | Computer Use | Desktop backends, permissions and setup. | | Context Fabric | Context management and retrieval. | | Tool protocol | Tool discovery and execution. | | Benchmarks | Evaluation suites and how to run them. |

This README is available in four languages. The extended technical guides are currently primarily in Italian.

Development

bun run typecheck
bun run typecheck:bench
bun run test:unit
bun run build

Unit test files run in separate processes. For one suite: bun run test:unit -- test/queued-questions.test.ts. See the E2E documentation for integration test setup.

Report bugs in Issues with your platform, Bun version, reproduction steps and relevant logs, with credentials removed.

Project and license

Created by Lorenzo Daniel Danilov at Vascend Technologies, an Italian AI lab. Inspired by the extensible agent philosophy of Pi.

Talos is available under the MIT license. Copyright (c) 2026 Lorenzo Daniel Danilov and Vascend Technologies. Source repository: VascendTechnologies/vascend-talos.