Eigent Release Notes v1.0.3: Durable Tasks, Git-Backed Spaces & Workspace Bundles

Eigent v1.0.3 is a release about making serious work last. Tasks can recover after an interruption, each Space can keep a reviewable version history, and the files, terminal output, approvals, and context around a Session remain available when you return.

The release also introduces Workspace Bundles for reusable agent configurations, scoped Memory for knowledge that should outlive one Task, a stronger in-session Browser, Files, and Terminal experience, and a new built-in model provider. Together, these changes turn Eigent from a place where work runs into a durable workspace where work can continue, be inspected, and be reused.

---

🔄 Durable Tasks That Can Resume Safely

Long-running agent work should not become disposable because an app refreshes, a connection drops, or a desktop process restarts.

Major thanks to @4pmtong for leading the Workspace Bundle product integration in PR #1842, including the durable execution foundation behind v1.0.3.

Eigent now records the important boundaries of a Task—attempts, tool activity, approvals, timeouts, cancellation, terminal state, generated artifacts, and recovery status—in a durable history. If work is interrupted, Eigent can reconstruct what happened and offer a safe path forward instead of treating the Session as a blank slate.

What's new:

• Resume after refresh or restart — return to an interrupted Task and continue from its recoverable state
• Completed work stays completed — recovery does not automatically repeat external actions that already succeeded
• Durable approvals — pending questions and approval decisions survive UI and transport interruptions
• Elapsed time survives reloads — Task duration remains accurate across recovery
• Follow-ups wait for safe boundaries — new instructions can queue until the current Task reaches an appropriate boundary
• History is reconstructed from events — messages, tool activity, plans, files, progress, and recovery states come from the same durable record

The most important change is not simply that a Task can restart. It is that Eigent distinguishes between work that is safe to resume and an external action whose outcome may be unknown. In the uncertain case, the system stops and asks for acknowledgement rather than guessing and risking a duplicate side effect.

🔗 PR: https://github.com/eigent-ai/eigent/pull/1842

---

🌿 Git-Backed Spaces with Task-Scoped Change Review

A Space is now more than a folder containing the latest output. It can be a versioned working environment with a clear history of what changed and when.

Eigent automatically initializes version history for Eigent-managed Spaces. If the folder you select is already a Git repository, Eigent reuses it instead of replacing its structure. During agent work, durable checkpoints and Task-scoped boundaries make it possible to separate one Task's changes from the rest of the workspace.

What's new:

• Automatic version history — Eigent-managed Spaces receive Git-backed history without manual setup
• Existing repository support — folder-backed Spaces adopt the Git repository already present
• Task-scoped file changes — review the files changed by a specific Task instead of comparing an ambiguous workspace snapshot
• Diff review — inspect additions and deletions before deciding what to do next
• Durable checkpoints — preserve meaningful recovery and review points throughout the work
• Branches and version history — understand how agent work relates to the wider Space over time
• Isolated multi-agent workspaces — agents can work independently while Eigent preserves a clear primary workspace

This makes agent output easier to trust. You can inspect not only the final file, but also the change boundary that produced it.

🔗 PR: https://github.com/eigent-ai/eigent/pull/1842

---

🖥️ Browser, Files, and a Real Terminal Inside the Session

The in-session side panel now works as an active part of the workspace, not only a place to look at an output.

Thanks to @Douglasymlai for adding the Browser, Files, and interactive Terminal experience in PR #1761.

You can open a web page, inspect generated files, or use a real local shell without leaving the Session. Preview tabs stay scoped to the correct Session, and their state remains available while you switch between Sessions. The terminal also lets you open live or historical output produced by developer agents, scripts, and background processes.

What's improved:

• Tabbed workspace tools — add, select, and close Browser, Files, and Terminal tabs from one panel
• Embedded browser controls — navigate with an address bar, back, forward, reload, and open externally when needed
• Interactive local shell — work with your normal shell profile, PATH, colors, keyboard input, resizing, and full-screen terminal programs
• Space-aware working directory — folder-backed Spaces open the shell in the correct local root
• Persistent terminal state — PTYs and scrollback remain available across tab switches and renderer remounts
• Agent terminal history — inspect live and historical output created during agent work
• Safer environment handling — credential-like environment values are filtered before the shell environment is exposed

The result is a tighter review loop: ask an agent to build something, open the artifact, inspect the supporting terminal output, and continue the conversation without reconstructing the context in another app.

🔗 PR: https://github.com/eigent-ai/eigent/pull/1761

---

📄 Generated Files That Are Easier to Open and Review

Files are now durable artifacts connected to the history of the Task that produced them.

Eigent can replay generated-file information from an artifact manifest instead of relying on transient UI state. Local HTML, images, PDFs, text, and larger files receive more dependable previews with bounded loading behavior.

What's improved:

• Durable artifact manifests — generated files remain discoverable when a Task is reopened or recovered
• Broader local previews — open HTML, images, PDFs, text, and larger artifacts inside Eigent
• Relative HTML assets — local HTML previews can resolve their supporting files correctly
• Bounded large-file loading — previews avoid pulling unbounded content into the interface
• Clear review intent — opening a file shows the artifact itself, while View changes opens its Task-scoped diff
• Task-specific change lists — file changes stay attached to the work that produced them

That separation matters: sometimes you want to read the result, and sometimes you want to audit exactly how it changed. v1.0.3 gives each action a clear path.

🔗 PR: https://github.com/eigent-ai/eigent/pull/1842

---

📦 Workspace Bundles: Reuse the Whole Working Setup

Repeated work often depends on more than one prompt. It needs the right agents, skills, tools, models, context, permissions, environment, and credentials to be assembled correctly before the Task starts.

Workspace Bundles package that setup into a reusable configuration. A Bundle can describe the workforce and its operating requirements, then guide the user through validation and configuration before anything runs.

A Workspace Bundle can include:

• Agents and skills — define the specialists and instructions the workflow expects
• MCP destinations — declare the external tool connections required by the Bundle
• Model profiles — provide supported model configuration for the workforce
• Context sources — identify the material that should be available when work begins
• Permissions — make sensitive capabilities explicit instead of implicit
• Environment requirements — describe what the runtime needs to execute successfully
• Secret slots — request required credentials without embedding secret values in the Bundle

Eigent distinguishes between installation readiness and runtime readiness, validates MCP destinations and required settings, and resolves secrets at runtime without placing sensitive values into a shareable manifest.

For teams, this creates a practical bridge from “here is how we usually do this” to a reviewed configuration that can be installed, completed, and run again.

🔗 PR: https://github.com/eigent-ai/eigent/pull/1842

---

🧠 Scoped Memory Without Rewriting Task History

Not every useful piece of context belongs inside one conversation, and not every past message should become permanent guidance.

v1.0.3 adds Memory that can be scoped to the User, Space, or Session. Notes can be searched, organized, confirmed, and archived, then brought back into future work at the right level.

What's new:

• User Memory — retain preferences or reusable knowledge that should follow you across Eigent
• Space Memory — keep context that belongs to one durable workspace
• Session Memory — preserve guidance relevant to a particular stream of work
• Search and organization — find and manage saved notes instead of relying on an opaque summary
• Confirmation and archive controls — decide what remains active context and what should be retired
• Separation from canonical history — editable Memory does not rewrite the durable record of what a Task actually did

This gives context a lifecycle. Task history remains the source of truth for past execution, while Memory becomes the curated layer you intentionally carry forward.

🔗 PR: https://github.com/eigent-ai/eigent/pull/1842

---

🛡️ Safer Approvals, Recovery, and Workspace Operations

Durability is only useful when it preserves the safety boundary around the work.

Eigent v1.0.3 persists permission decisions before execution continues, makes mutable Task-control requests idempotent, and keeps Task ownership checks attached to local control APIs. Git operations, workspace mutations, tool execution, cancellation, and deadlines all use explicit boundaries so recovery does not silently cross from inspection into action.

Reliability and safety improvements:

• Unknown side effects fail closed — uncertain external outcomes require explicit acknowledgement
• Persisted human interaction — approvals and responses are recorded before the Task proceeds
• Idempotent Task controls — retries do not create duplicate mutable operations
• Ownership checks — Task-control APIs enforce the correct workspace boundary
• Sensitive-value protection — secrets are rejected from unsafe manifests, arguments, and transport paths
• Hardened terminal lifecycle — terminal creation, restart, reattachment, cleanup, and late callbacks are handled defensively
• Improved cancellation and timeout handling — interrupted work reaches a clearer durable state

These safeguards make recovery conservative where it should be: Eigent can continue known work, but it does not invent certainty about actions outside the app.

---

✨ Ant Ling Support and Focused UX Fixes

Thanks to @tangxinyao for adding Ant Ling as a built-in OpenAI-compatible model provider in PR #1823.

Ant Ling now appears directly in the model settings UI with its provider metadata and models endpoint. The backend maps it to Eigent's OpenAI-compatible model adapter, so users can select it as a first-class provider instead of manually rebuilding the configuration through the generic option.

This release also fixes the folded Task view scrolling unexpectedly. Thanks to @Douglasymlai for restoring the intended non-scrollable folded state in PR #1698.

🔗 PR: https://github.com/eigent-ai/eigent/pull/1823

🔗 PR: https://github.com/eigent-ai/eigent/pull/1698

---

🔁 Compatibility for Existing Work

Existing Spaces, Sessions, and Task history remain available after upgrading to v1.0.3. No additional configuration is required for the default experience.

The durable event-based task experience also retains compatibility paths for existing Session and historical Task data while the newer projection model rolls out. That lets Eigent strengthen its execution foundation without asking users to abandon the work already stored in the app.

---

❤️ A Workspace You Can Return To

Eigent v1.0.3 delivers:

• Durable Tasks that can recover after refreshes, restarts, and interruptions
• Safe resume behavior that does not automatically repeat completed external actions
• Git-backed Spaces with checkpoints, version history, and Task-scoped diff review
• In-session Browser, Files, and interactive Terminal tools with persistent state
• Durable generated-file manifests and broader local artifact previews
• Workspace Bundles for reusable agents, skills, MCPs, models, context, permissions, environments, and secret requirements
• Scoped User, Space, and Session Memory with search, confirmation, and archive controls
• Stronger approval, timeout, cancellation, terminal, and sensitive-data boundaries
• Ant Ling as a built-in OpenAI-compatible model provider

The theme of this release is continuity. A long-running Task can survive disruption. A Space can show how its files evolved. A Bundle can carry a complete working setup into the next Session. Memory can preserve the context worth keeping without changing the historical record.

That is what makes an agent workspace dependable: not only the ability to start work, but the ability to return, understand what happened, and continue safely.

🔗 Release: https://github.com/eigent-ai/eigent/releases/tag/v1.0.3

🔗 Full changelog: https://github.com/eigent-ai/eigent/compare/v1.0.2...v1.0.3

Let's keep building.