Skip to content

Releases

v0.1.3

Choose a tag to compare

@github-actions github-actions released this 13 Nov 20:12
Immutable release. Only release title and notes can be modified.

This security release fixes file and command rules, record verification, and the handling of skipped kernel checks.
If you use Tego v0.1.0, v0.1.1 or v0.1.2, upgrade and restart your runs.
The v0.1.1-rc.1 prerelease is affected too.

Security

  • Denied reads at tiers cgroup and bpflsm: a host could already show a denied folder, or part of it, at another
    readable place on the same filesystem. A read through that place could miss the denial. This affects v0.1.0
    through v0.1.2. The fixed build refuses to start where the selected mechanism cannot hold the denial through
    those names. A decision plane still handles whole-folder names on the same filesystem where supported.
    Different filesystem instances that show the same data remain a limit. So do later host mounts, ancestor
    renames and rules that protect names rather than existing paths. Tier landlock keeps its stated alias limit.
    Hosts that already show a home or project folder at a second place, such as Fedora Atomic, toolbox and
    distrobox hosts, can meet this refusal where the selected mechanism cannot hold that second place;
    tego doctor names the places it found.
  • Protected writes: in v0.1.0 through v0.1.2, a write or ask grant could reach kernel control files or Tego's own
    files through another existing mount. A user-writable Tego binary with another hard link was also exposed.
    An agent could change another run's controls or a binary used by a later run. Compile and run start now refuse
    grants that reach these protected places within the mount analysis's stated limits. Mount changes after compilation, separate
    filesystem instances and backing storage whose identity is not known remain limits. Keep that storage outside
    every write and ask grant. Processes outside Tego still have their ordinary rights.
  • Command rules in v0.1.0 through v0.1.2 could miss some subcommand entries in exec.deny and exec.ask for
    systemctl, go, npm, pip and aws. It matters when the program may run and the contract relies on a subcommand
    entry. These command forms now match; some other tools refuse more commands where their parsing is
    uncertain. Whole-program refusals, file rules, network rules and ordinary OS privileges applied throughout.
    exec.ask is still reserved and refuses; it does not ask a person.
  • Option-specific npm refusals could be missed, and some npm argument combinations could be admitted under
    an allow entry for another command. Command rules now check the command and options npm reads, including
    value assignments, option spellings and shorthands. Existing conservative refusals remain in place.
  • AWS options written as assignments remain options when a preceding option needs a value. Missing values
    refuse constrained command rules; uncertain spellings retain conservative readings.
  • Command entries containing an option terminator follow the tool's command, default command and argument
    boundaries. Unknown tools keep literal argument regions. Unestablished allow meanings and unsupported
    separator spellings fail to compile. Refusals of the compared inputs remain (the known limits below name
    one exception), and allow entries retain their prior limits.
    An allow entry does not admit its command when the command line puts -- before the subcommand; write the command without it.
  • This release decides command rules with two readings of each entry and command line: the corrected reading
    and a retained earlier reading kept as a floor. A deny or ask entry applies when either reading matches. An
    allow entry for a constrained program admits a command only when both readings do, and an allow entry the
    retained reading cannot interpret fails to compile, naming the entry. So some commands that an allow entry
    would admit under the corrected reading alone stay refused in this release.
  • Known limits of command rules in this release. The reading that tego compile prints for a command entry
    is one of the two readings the decision uses; where they differ the decision is the stricter one, so
    the printed reading can show more than is allowed or less than is refused. An entry whose option word
    has an empty name is read as written; earlier versions could read it as a command's only long option, so a
    deny or ask entry written that way no longer matches that option, and compile does not warn:
    write the option's name. The comparison with the released matcher covers generated single-entry
    contracts and pinned cases, not every contract (GAPS C72).
  • Since v0.1.0, some Git command entries could miss a built-in run under one of Git's alternative names.
    Deny or ask entries naming add, init, fsck or blame were affected, as were entries for commands found in
    Git's helper directory but absent from Tego's command table. The fixed build applies those entries to the
    affected names in Tego's table and helper list. If you rely on these Git command rules, upgrade.
  • Ledger roots outside ~/.tego: versions v0.1.0 through v0.1.2 (including v0.1.1-rc.1) checked the ledger root's
    parent when deciding whether a write grant was inside a run's folder. With such a configured ledger_root, a
    grant inside an existing run's folder was not refused and could change that run's record and control files.
    Compile now checks the ledger root itself and refuses these grants, including through another mount of the same
    filesystem within the compile-time mount boundary.
    This defect alone did not let the agent write its own newly created run folder: run start separately
    refuses a direct grant covering that folder. Upgrade if you use a ledger root outside ~/.tego, and review write
    grants that reach existing run folders.
  • Record verification in v0.1.0 through v0.1.2 could accept a record only as far as the line before an altered
    final line. This required write access to the record and no populated anchor entry for that run. Verification
    now checks a closed final JSON value and rejects malformed trailing content. An intact populated anchor
    remains necessary to detect a removed tail. An integrity check does not prove who made a record or that the
    actions in it were allowed.
  • Kernel checks at root tiers: in v0.1.0 through v0.1.2, some preempting kernels could skip a program that should
    decide an action, without recording that loss. LSM checks were exposed before Linux 6.2, or before 6.1.54 in
    the 6.1 series, when kernel code could be preempted. The measured distribution defaults did not expose that
    older case. Exec pins were exposed on measured Linux 7.0 configurations. Listener cleanup could skip on
    preempting kernels. A run now reads the relevant skip counters. A detected
    decision skip ends a governed run with reason error and a gap saying its rules may not have held. An adoption
    reports the gap without ending the agent. Doctor withholds unsafe LSM modes and kernel exec assurance on the
    affected configurations. Exec pins and listener cleanup can still be skipped. Detection does not undo an
    action. Shared counters can end an unrelated run, and unmeasured vendor kernels remain a limit.

Added

  • In a terminal, tego doctor, test, watch, learn, run, adopt and agents end with a next: line on
    stderr that names the one command to type next. TEGO_HINTS=off turns these lines off, and TEGO_HINTS=on
    turns them on where stderr is not a terminal; they are never printed with --json. No stdout line changes:
    tego doctor's Ready or Not ready line is on stderr, after its report.
  • tego learn <run> --save <name> writes the proposed contract, compiled first, to the user registry, so
    tego run <name> finds it. It refuses a name that tego run would not find alone from the working directory
    or from the run's folder, a name that starts with -, and running under sudo for another user. The contract
    it saves has reason: {reads: on}, so a read the contract refuses is recorded at tier landlock too and a
    newcomer sees the refusal on every run; one line says what it costs (each read open about 17 µs slower), and
    --reads off leaves it out. The printed proposal, --out and contracts already saved do not change.
  • tego learn --allow-host <host>[:<port>] (repeatable, at most 8) names the service a watched run reached at
    some of its addresses. Tego looks the name up now and writes tcp://<host>:<port> (udp:// for UDP) in place
    of each address the run reached that the name resolves to. A later run is then allowed the addresses Tego's own
    lookups of the name return during that run, not only the one this run reached. An address no name may stand for
    (loopback, link-local, cloud metadata, or a range in the machine config's denied_resolved_addresses) stays an
    address. It writes nothing and exits 1 when the name does not resolve within 2 s, covers no address the run
    reached, resolves to a private address the run did not reach, or resolves to an address learn withheld after a
    secret read. It never chooses a name itself. When a proposal still allows addresses, stderr names them, and the
    next: line after tego watch and tego learn adds --allow-host <host>. The machine's resolver is never
    counted as an address to name (see Changed).
  • After a run whose refused reads were not recorded, a reads: line on stderr says so, and
    tego receipt --json carries reads_notified.
  • tego setup checks the machine from your shell and lists the six steps from install to an agent held by its own
    contract, each with the fact that decided it, then the one command to type next. It asks nothing, starts no
    program and needs no root; --json prints one object (tego.setup/1) and -v says where each fact was read. It
    stores its check in ~/.tego/state/check.json, used only on the same boot with the same tego build; tego doctor
    still writes nothing. The installer ...
Read more

v0.1.2

Choose a tag to compare

@github-actions github-actions released this 12 Nov 02:26
Immutable release. Only release title and notes can be modified.

This patch fixes one flaw in how command rules read long command lines. It changes no other code.

Security

  • Command rules (exec.deny, exec.ask, and exec.allow entries with words after the program): Tego decides a long
    command on its first part (32 arguments, or fewer when they pass 8 KiB) when the rest cannot change the answer. In
    three forms the rest could still change it, and the command was decided on its first part anyway, so it ran though
    its whole command line is refused:

    • python's -m as the last argument of the first part, with the module after it: an entry on the module, such as
      deny: [pip install] or a bare deny: [pip], was not applied;
    • cargo's --config or gcloud's --flags-file after the subcommand: --config can define an alias that runs
      cargo publish under another name, and deny: [cargo publish] was not applied to it; under allow: [cargo build]
      such a cargo build ran, which Tego refuses because it cannot tell which subcommand runs;
    • options after the -c of sh, bash, dash, zsh or ksh, or after the -e of perl or ruby, enough of them that the
      whole command line cannot be resolved (more than 16 ways to read it), which Tego refuses.

    Present since v0.1.0: the new tests fail on trees of v0.1.0 and v0.1.1 (unit tests, not run in a guest). The file
    and network rules, and which programs exec.allow lets run at all, were not affected. If you rely on command
    entries in exec.deny, exec.ask or exec.allow, upgrade to v0.1.2. These commands are now read to their end,
    or until no later argument can change the answer. A command that would have to be read past 8192 arguments or
    128 KiB of argument text to be decided is refused (args-unreadable), where before it could be decided on its
    first part.

Record v

1 (spec/record/v1, record minor 29)

Contract schema

0 (spec/agent/v0; the field set may change without notice before v0.2.0, docs/VERSIONING.md section 3)

Kernel minimums

Linux 5.14 with Landlock ABI 2 or newer, which is Linux 5.19 or a backport such as RHEL 9's 5.14; tested from 6.1 and on
RHEL 9 and 10, as AlmaLinux 9.8 and 10.2, with what ran where in docs/TIERS.md (tier 1: ABI 1 is unsupported,
and features are gated per ABI, see spec/backend/CAPABILITIES.md;
tier 2 needs root and cgroup v2; tier 3 needs root and bpf in the LSM list). A unix socket under an fs.write path is
admitted without a unix: entry only with the kernel's socket diagnostics for AF_UNIX (CONFIG_UNIX_DIAG, built in
or the loadable unix_diag module); without them such a socket is refused unix-origin-unread, and tego doctor says so.
Syscall outcome hooks require readable tracefs event formats with an eight-byte ret at offset 16; unsupported
or unverified layouts withhold root tiers. The kernel version minimum is unchanged.

Container image

ghcr.io/attention-span-ai/tego@sha256:ca05e8f43f706d0f2263540dcd6d47a5ef611f350b148f8df25b1c4f9aeb5117 (linux/amd64, linux/arm64).

v0.1.1

Choose a tag to compare

@github-actions github-actions released this 11 Nov 09:16
Immutable release. Only release title and notes can be modified.

This patch tightens the built-in refusals around an agent and checks the file identities and security labels
used for approvals. Receipts and the dashboard give more reliable results for long runs, tego rules brings the
rules view to the terminal, and release automation adds signed container images alongside the binaries. MCP tool
rules remain a preview, with the limits below.

Security

  • Tiers cgroup and bpflsm, on overlayfs: on kernels that have file_operations.fop_flags but keep FMODE_BACKING at
    bit 25 (RHEL 9.8, RHEL 10.0 to 10.2, Linux 6.10 to 6.13, and 6.12 stable before 6.12.105), the decision plane did
    not recognise an overlayfs backing file. An agent could map a file under a write entry readable and mprotect it
    executable, which lets it run that file's machine code although no exec.allow covers it. A direct executable
    mmap was still refused. Present since v0.1.0. The plane now recognises a backing file whether FMODE_BACKING is
    bit 24 or bit 25, which covers every kernel checked from 5.14 to 7.1. Measured on AlmaLinux 9.8 and 10.2 for a
    file already on the overlay mount: the old build allowed it and the new build refuses it. The other kernels in
    the list are read from their headers.
  • Syscall outcome hooks refuse loading or adoption unless tracefs proves an eight-byte return at offset 16.
    Doctor and run tier selection withhold root tiers on unverified layouts and retain the reason.
  • Enforcing runs refuse protected host IPC, Tego control surfaces and other terminals before grants. Own
    runtime, fixed SSH-agent exceptions, inherited terminals and policy-checked own PTYs work; exact
    container-daemon socket grants warn of escape authority. Root tiers add native Unix peer checks and reject
    io_uring: true. Limits remain for inherited descriptors, new outside FIFOs, unlisted server paths and
    datagram/copied-path cases without native checks.
  • Held opens require matching complete AppArmor labels with proven root namespace visibility, or matching
    SELinux contexts and fscreate for potential creation. Smack refuses: another task's rules cannot be queried.
    Unknown facts refuse approvals and alternates. An unprivileged syscall discovers LSMs behind masked
    securityfs. Containers need them; hidden AppArmor namespace depth gives EACCES / held-label-unavailable by
    default. Administrators can waive only unreadable depth with fs.apparmor_assume_root_namespace: true in the
    top-level contract, accepting hidden-ancestor risk; compile warns and run_start.best_effort records it.
  • Held reads track protected identities through renames, hard links, replacements and moves, including
    denied-directory descendants. Approvals (including write-only) and alternates recheck opened identities. Lost
    mutation history or unsupported filesystems refuse held reads; new name matches outside the launch snapshot
    and mount changes undone between reads remain limits. Held writes recheck live blocks.
  • Record, lock and anchor writers reject hard links for everyone. Owners can still alter records; historical
    readers and garbage collection gain no link-count checks.
  • Stdio MCP starts pin the admitted shim's exact child before exec, refusing preexisting children; failed
    registration refuses. mcp relay * grants use an authenticated private stage, honoring denies/asks without
    permitting other children or subcommands. Protocols v1/v2 refuse: rebuild launcher and shims together. MCP
    stays a preview (tego serve --preview exposes its dashboard link): ptrace/socket-copy authority can bypass
    decisions and their record; alternate command spellings need separate exec rules (GAPS C50).
    Hardening remains proposed in ADR
    0126
    .
  • Boundary adoption arms its empty destination before moving processes. The agent cannot use CAP_SYS_ADMIN in
    any user namespace, covering mount changes and mount-namespace installation; missing hook proof refuses
    adoption. Record-only adoption stays unrestricted. Earlier changes, operations past capability checks, outside
    processes, inherited descriptors/mappings and pre-attachment actions remain outside protection. Adoption
    refuses network contracts (net:); it cannot enforce them.
  • Node rules scan config and dotenv options wherever Node scans them. Expanded parsing needs exact standalone
    Linux x64 builds 20.19.4 or 22.21.1; others keep bounded parsing plus these scans. Unknown builds may miss
    code-loading options; external NODE_OPTIONS preloads remain unread.
  • The release is built with Go 1.27.4, which fixes GO-2026-6859 in net/http: an HTTP/1 server could crash when a
    handler reads a request body limited by MaxBytesReader while response headers are written on another goroutine.
    tego-control's dashboard is an HTTP/1 server on 127.0.0.1 and limits form posts with MaxBytesReader; it reads
    each form in the handler's own goroutine, before writing a response.

Fixed

  • On RHEL 9 (AlmaLinux 9.8 tested), systemd turns on the memory and pids controllers by default, but not cpu.
    tego doctor failed on that and found no tier, so every enforced run was refused, including runs with no
    limits, for a user and for root. Now only a run that sets limits.cpu or limits.cpu_weight is refused, at
    start, and doctor and the refusal give the one-time setup that turns cpu on (docs/TIERS.md, GAPS B15). A
    limits.cpu ceiling in /etc/tego/config.yaml gives every tego run a CPU limit, so with one they are all
    refused, although tego doctor still reports tier landlock for a user. Memory and process limits apply. For
    root, doctor's fix now names a CPU weight on system.slice instead of user@.service, because a hand-written
    +cpu in the root cgroup does not last under systemd.
  • RHEL 9 root-tier runs with net.listen can attach their required bind/listen outcome hooks. Bind, listen
    and exec outcomes use the individual syscall event's BTF context; v0.1.0's listener preparation failed on
    the tested RHEL 9 5.14 layout. No required hook or enforced property is dropped.
  • Root-tier recording samples shared tracing skips from the programs executing through active links.
    Receipts and views report bpf-trampoline-miss/shared-build as shared skipped executions, with incomplete
    coverage, rather than known lost events. Missing, changed or unreadable attachments/counters report uncertainty;
    skips may belong to other runs or ungoverned tasks, and overlapping runs may count the same skip. Preemptible
    kernels can still lose records (GAPS C53).
  • Built-in .env rename refusals and tego learn explain root-tier pip's name-coverage limit (C55) and its
    measured contract/cwd remedy in OPERATIONS.md.
    Write entries alone add no name coverage; pip's copy fallback can exit 0 while recording rename refusals.
  • Kernel-matrix guests prepare delegation and authenticated Unix diagnostics/loop modules; doctor-only checks
    accept combined remedies. Automount tests use the same kernel's native result, and conformance releases
    compile-only fixture trees before kernel tests. The 6.1 plane retains its probe reader and kernel minimum.
  • Protected host-server paths that the invoking user cannot traverse no longer prevent startup; reachable
    objects remain pinned and unexpected identity errors still refuse launch. Compiled built-in entry names stay
    the same when host servers are installed or removed.
  • Native Unix peer checks use the correct kernel-memory reader, and protected-name walks keep the original
    verifier instruction budget across kernels.
  • Permitted overlay copy-up can use kernel-installed filesystem credentials without granting the agent
    CAP_SYS_ADMIN; task-initiated mount changes and trusted xattr operations, including through an io_uring
    personality, remain refused. Missing kernel bind/listen metadata is explicitly disclosed instead of inferred
    from a copied attempt. Frozen bind lookup errors keep supervisor ownership and one observed result with their
    actual errno.
  • Interactive Claude examples use short private session socket paths, check the complete path at launch and
    refuse an overlong path with a fix. PTY peer delivery checks filesystem policy, live blocks and gates without
    changing the supervisor's controlling terminal.
  • Developer correctness tests synchronize with observed readiness, lock state and peer admission, and bound Unix
    socket fixture paths. Fast-path timing tests retain their original uninstrumented budgets in
    scripts/timing-budgets.sh, with separate instrumented unit/race ceilings; production limits are unchanged.
    The VM matrix, run by hand before a release, requires live SELinux/Smack policy fixtures without skips;
    per-PR CI omits these proofs.
  • Dashboard event windows, indexes and pending asks have bounded retained state, with partial-history labels and
    explicit truncation. Full-ledger receipts report a limit error rather than an incomplete unanswered-ask count.
    Historical reads may rescan disk; these budgets are not a process memory cap.
  • Dashboard live regions retry after a failed refresh even if no new event arrives. Watched-run comparisons
    require matching workspace and agent identity, preserving warnings when that identity is absent or different.
  • Receipts, dashboard verdicts and learned rules keep successful read/send pairs together; an unrelated refusal
    no longer creates a leak warning. Proximity remains a heuristic. Newly written refusal/mirror pairs are
    contiguous, and created-link and unanswered-ask totals agree across views; older displaced mirrors can remain
    ambiguous.
  • Fresh agent setup generates explicit, portable Claude print-mode and Codex contracts without seeding
    credentials. Codex settings-source notes appear in compile and verbose output, keeping ordinary starts quiet.
  • Agent selec...
Read more

v0.1.1-rc.1

v0.1.1-rc.1 Pre-release
Pre-release

Choose a tag to compare

@github-actions github-actions released this 11 Nov 08:31
Immutable release. Only release title and notes can be modified.

This is a release candidate for v0.1.1, with the changes listed under v0.1.1 in docs/CHANGELOG.md. It exists to
rehearse the release run: signed binaries, the container image and the published notes. Use v0.1.0, or wait for
v0.1.1, unless you are testing the release itself.

Record v

1 (spec/record/v1, record minor 29)

Contract schema

0 (spec/agent/v0; the field set may change without notice before v0.2.0, docs/VERSIONING.md section 3)

Kernel minimums

Linux 5.14 with Landlock ABI 2 or newer, which is Linux 5.19 or a backport such as RHEL 9's 5.14; tested from 6.1 and on
RHEL 9 (tier 1: ABI 1 is unsupported, and features are gated per ABI, see spec/backend/CAPABILITIES.md;
tier 2 needs root and cgroup v2; tier 3 needs root and bpf in the LSM list). A unix socket under an fs.write path is
admitted without a unix: entry only with the kernel's socket diagnostics for AF_UNIX (CONFIG_UNIX_DIAG, built in
or the loadable unix_diag module); without them such a socket is refused unix-origin-unread, and tego doctor says so.
Syscall outcome hooks require readable tracefs event formats with an eight-byte ret at offset 16; unsupported
or unverified layouts withhold root tiers. The kernel version minimum is unchanged.

Container image

ghcr.io/attention-span-ai/tego@sha256:7dde984630a1e81cfa10c73d12c3ae8a4457dbed3d59d712efa289c9b3258370 (linux/amd64, linux/arm64).

v0.1.0

Choose a tag to compare

@github-actions github-actions released this 04 Nov 07:48

The first release. Tego runs an AI coding agent under a contract you write, a YAML file of rules for files, programs
and network hosts, and enforces it from outside the agent: the Linux kernel and Tego's supervisor refuse what the
contract rules out, can hold an action until you answer, and keep a hash-chained record of every run. Tego runs on
Linux (amd64 and arm64); on macOS and Windows it runs inside a Linux VM. It sends nothing home and never calls a model
itself.

Install

  • Linux: curl -fsSL https://github.com/Attention-Span-AI/Tego/releases/latest/download/install.sh | sh installs
    tego and tego-control into ~/.local/bin, checks them against the release's checksums, and checks who published
    them when cosign or a logged-in gh is on PATH.
  • macOS: limactl start --name=tego https://github.com/Attention-Span-AI/Tego/releases/latest/download/tego.yaml
    starts an Ubuntu 24.04 VM with Tego installed (brew install lima first).
  • Windows: wsl --install -d Ubuntu-24.04, then the Linux line inside Ubuntu.
  • From source: make build (Go 1.27). docs/INSTALL.md has every route and what each was tested on.

Added

Contracts

  • tego init writes a starter contract, from the built-in presets no-secrets, no-prod and repo-only-writes with
    --preset; tego compile checks one and prints its rule table, and --test asks what each tier would do with an
    action; tego learn proposes a contract from what a finished run did. Revision 1 of each preset is frozen from this
    release on.
  • Rules for files (fs), programs (exec), network hosts and ports (net), environment variables and limits (tokens,
    cost, time, stalls, repeats, memory, processes). A run that passes a limit ends with exit code 124.

Three enforcement tiers, all in the release binary

  • Tier 1 (landlock), no root: Landlock and a seccomp supervisor. The kernel refuses writes and programs outside the
    contract; Tego's supervisor decides network hosts.
  • Tier 2 (cgroup), root: BPF programs attached to the run's cgroup, and fanotify. Hosts are decided in the kernel.
  • Tier 3 (bpflsm), root, on a machine with bpf in the boot LSM list: BPF LSM hooks.
  • tego doctor says which tier a machine gets and prints a fix for each gap; tego test shows four harmless actions
    refused at that tier, with no root and no agent.

Live rules and approvals

  • An ask rule holds a file open or a connection until you answer with tego approve or tego deny, or in the
    dashboard. Held file reads (fs.ask_read) are tier 1 only; exec.ask is reserved and refuses.
  • A running run can be paused, resumed, stopped and blocked (tego pause, resume, stop, block, unblock), and
    tego rule turns something a run did into a rule. A run in the Adjustable live mode (tiers 2 and 3) can also be
    loosened while it runs (docs/user/live-modes.md).
  • MCP tool rules: a relay allows, holds or denies single tools of an MCP server, and tego mcp changes that live.

The record

  • Every run writes a hash-chained record, anchored in ~/.tego/chain.log. tego receipt summarises a run, tego events
    prints it and tego events <run> --verify checks its chain, tego drift compares what was allowed with what was
    used, and tego measure counts steps, tokens, cost and time. What the record holds depends on the tier: by default
    tier 1 records programs, writes and connections, and no file reads (record: full records reads).

The dashboard

  • tego serve --open serves a dashboard on 127.0.0.1:8484 for one person: runs, logs, refusals, held requests to allow
    or deny, each run's rules, and stop, pause and block. It runs as tego-control, which refuses to run as root.

The agent watcher

  • tego watch runs any command as a black box and records what it does. tego agents lists the agent processes
    running on the machine and tego adopt moves one that is already running into a governed run; both need root.

Supported agents

  • examples/agents/ has contracts for Claude Code (print mode and the full-screen interface), OpenAI Codex (API key
    through Tego's forwarder, or a ChatGPT sign-in), a Python agent on the Claude Agent SDK, one on the Anthropic Python
    SDK, a Python retriever with one MCP server, and an agent of your own left to run unattended. Any other agent is an
    ordinary process: write a contract for it, or start with tego watch.

Release

  • Static binaries for Linux amd64 and arm64, with the tier-2 and tier-3 BPF objects built in. The checksums file is
    signed with cosign (keyless, by this repository's release workflow at this tag) and every file it lists has a build
    provenance attestation; the binaries are built again from the tag on a fresh runner and must match byte for byte
    before the release is published. install.sh and the macOS template tego.yaml are release assets too, in the same
    checksums file, and the one-line installs take them from the latest release. tego_0.1.0_licenses.tar.gz holds the
    licence texts, and tego licenses prints them.

Security

Fixed since the source was first published on 2026-11-02.

  • In fmod_ret plane mode the kernel could skip a deciding program on a CPU where a preempted task was still inside it,
    and the hooked call then went ahead undecided: on kernels that preempt kernel code (full or lazy preemption, the
    default on 7.0 kernels) an agent could open files its contract denies. A release build now uses fmod_ret mode only
    where the kernel provably cannot preempt kernel code (a fixed none or voluntary build, or a dynamic build whose
    debugfs mode says none or voluntary, read again at every run and adoption); elsewhere tego doctor says why and
    tier cgroup uses LSM mode or the fanotify listener. Hosts whose debugfs cannot be read (for example under Secure
    Boot lockdown) no longer get fmod_ret mode.
  • A contract endpoint written with a mixed-case scheme (uniX:0) passed as a host name and skipped the Unix socket
    path checks; selectors must now be lowercase.
  • At tier landlock an agent could open a deny_write file such as .git/config for writing through a symlink whose
    body goes through its own /proc/self/task/<tid> and climbs back out. The supervisor now resolves such a link the
    way the agent's own lookup does, and the open is refused.
  • A run with a net: section can no longer source-route around its contract: setsockopt of IP_OPTIONS,
    IPV6_RTHDR, IPV6_2292RTHDR and IPV6_2292PKTOPTIONS fails EPERM, and a datagram whose control message routes it
    is refused with a relay-source-routed line (GAPS C34).
  • The built-in deny_read list also refuses the desktop keyrings, ~/.my.cnf, ~/.mylogin.cnf, ~/.s3cfg, ~/.boto,
    rclone's config, the RubyGems and Composer credentials, ~/.m2/settings-security.xml, and the doctl, hub, glab,
    flyctl, Supabase and OCI CLI stores.

Fixed

Since the source was first published on 2026-11-02.

  • Set up a new agent takes a long form and keeps a comment on the name line; removing an entry listed twice removes
    both; tego rule changes read in words in the dashboard's history and undo the right way.
  • tego gc and the retention pass prune the rule-change journal, keeping everything a run in the ledger root still
    reads and each rules file's newest 20 standing changes.
  • The Block now terminal line fills in what the form holds, quoted, and keeps a selection.
  • A run can no longer watch what it may not read: inotify, fanotify and dnotify watches of a deny_read target are
    refused.
  • Live blocks, gate rules and the model guard read this host the same way, local routes included (AnyIP ranges,
    hand-set broadcast and IPv6 anycast addresses).
  • tego init --preset makes a preset's folders with no link followed, and works inside a tego run.
  • An agent that runs chmod 000 on tego's own files no longer makes its run fail or refuses the runs after it; tego
    gives the owner back the rights it needs, and tego gc deletes nothing by a config layer it cannot read.
  • The dashboard reads a run whose launcher died as Lost within a few seconds, re-checks a cached chain verdict, and
    keeps a live host block's addresses fresh.
  • tego block notes a program whose file has other names (a multi-call coreutils or busybox) and a bare name on no
    PATH folder; the dashboard's Remove on an ended run is refused as tego unblock is.
  • The CLI's record views count a refusal once when its mirror line is not next to it, as the dashboard does.
  • tego rule and the dashboard's previews warn when a host a change adds does not resolve.
  • tego help marks the commands that need root; tego-control serve --addr takes [::1]; error pages keep the live
    chrome; file rows offer Block; compile --test says which tiers auto leaves out and why.
  • tego run's end line names the tier, and every command that takes a run accepts a unique abbreviation of its id; a
    bare short name is no longer read as a local run directory (use ./name).
  • The Rules page lists the machine's limit ceilings, net.http, ingress and gate rules and the tier-1 datagram residual,
    counts what the defaults decided, and counts every name of a program's file, git's helpers and a script's interpreter.
  • Logs and the line page say "Watched only" for a watched run's lines.
  • The line page streams a blob download instead of holding it in memory.
  • The demo kit runs under a pyenv or asdf python3 shim and says when a run did not start; the supply-chain demo's proof
    reads tego events --json, and its reset never deletes a folder it did not move.
  • tego watch and tego adopt name themselves in the run path's messages.
  • Logs: the path: query key matches whole names, so path:/a/b no longer lists /a/bc.
  • The dashboard words six refusal reasons it showed as bare codes (MCP tool blocked, Sandbox boundary, and the
    credential and model-route codes).
  • Never allow from a Deny on a connection opens that connection's own refusal; Make it perman...
Read more