Veyra

The operating system for AI workforces. Deploy AI workers that execute real tasks.

[Veyra @Veyra_OS]

VeyraOS is now live on @Pumpfun

Built for the future of autonomous AI workers.

Official links:

Website: https://t.co/BWbcN9A3DI

GitHub: https://t.co/KzKXNQUQ8s

CA: 8KEkGxRBdwjHFXHFwiLQUidrqSD8BdsufEvnH45Ypump

This is Day 1.

From here, everything is about building.

[Veyra @Veyra_OS]

here's everything we've shipped since launch. not a highlight reel — the whole build log.

what's live now

the core platform is running. you sign up, deploy an agent, pick a specialist — Deep Research, Code Architect, Admin Assistant, Data Analyst, Growth Hacker, Technical Support — and it spins up a real cloud sandbox in E2B, runs your task with web search and live code execution, and streams the output back token by token.

that part is done. tested. live.

we also shipped the memory layer. every agent reads its notes at the start of a task and writes back what it learned — preferences, patterns, how you want things formatted, context it should carry forward. the next time you run that agent it already knows you. not session memory. persistent identity across every run.

workspace context is in the Manage tab. agents know what they're working with before you even type the task.

what we've been building in the background — Missions

this is the big one. not live yet. but it's almost ready and here's the full picture of what we've built.

the architecture: a coordinated multi-agent workforce. you give VEYRA a goal. a planner breaks it into a chain of specialists. each worker runs their step, hands off to the next, and together they produce a deliverable that none of
them could alone.

parallel worker lanes: steps that don't depend on each other run simultaneously. deep research and data analysis that can work independently run at the same time. the system coordinates them and merges their outputs before passing to the next stage.

handoff compression: when a worker finishes, we don't dump its entire output into the next worker's context. a compression pass runs first — distils the raw output into structured key findings, decisions made, artifacts produced, and a one-sentence brief for the next worker. cleaner context, faster execution, better results.

mission templates: five pre-built worker chains. market research, competitor analysis, content brief, go-to-market strategy, research report. you pick the template, type a topic, and a fully planned parallel workforce fires immediately — no prompt engineering, no figuring out which workers to assign.

cost and token tracking: every worker reports its token count as it completes. running total in the header live during execution. per-worker cost on each card. full mission cost on the history card when it's done. you always know exactly what you're spending and where.

mission export: when a mission completes, the command centre blurs and dims and a white document card rises from the screen — the deliverable emerging from the machine that built it. formatted report, worker chain shown at the bottom, copy and download in one click.

what we fixed along the way

the search function was blocking the async event loop — every search call froze the entire stream. fixed by wrapping it in a thread pool.

E2B sandbox startup was adding 20-30 seconds to every mission. fixed by booting it in the background the moment a mission starts — workers begin immediately and the sandbox is ready by the time they actually need it.

worker cards were resolving by group index, which broke entirely once parallel lanes meant multiple workers shared the same index. fixed by tracking every card by step ID instead.

a stray closing brace in the event switch broke every navigation link in the app. found it, removed it.

the numbers

- six specialist agents live.
- five mission templates built.
- parallel worker execution shipping.
- handoff compression shipping.
- cost tracking shipping.
- mission export shipping.

Missions drops soon. everything above ships with it on day one.

[Veyra @Veyra_OS]

gm everyone. happy monday.

big week. finalising missions ahead of release - today is about getting the remaining pieces locked in before we open it up.

on the list for today:

cost and token tracking - every mission run will surface exactly what it cost. per worker, per step, total tokens used, dollar value. full visibility before and after every run.

after that we move into the wider roadmap — there's a lot in the pipeline beyond missions and we'll be sharing more on that as the week progresses.

missions has been a serious build. multi-agent orchestration, parallel worker lanes, handoff compression, shared sandbox, persistent memory, pre-built templates. the infrastructure is there. now we finish it properly.

let's get it.

[Veyra @Veyra_OS]

The goal

five years from now most knowledge work will involve AI in some form. the question isn't whether — it's how it's organised.

right now the default is fragmented. people stitching together four or five different tools, copying outputs between them, rebuilding context every time they switch. that works when AI is a nice-to-have. it breaks down when AI becomes infrastructure.

the goal with VEYRA is to be the workspace that serious work runs through. not because we locked you in — because we made it the best place to work. your agents know you. your missions are templated and reusable. your history is there. your costs are tracked. your deliverables come out formatted and ready to use.

as new models drop, you get them inside the same workspace. as capabilities expand, your agents gain new tools. as AI gets more autonomous, your workflows get more powerful — without you having to rebuild everything from scratch somewhere else.

the platform should evolve with the technology. your work shouldn't fragment every time it does.

that's why we built it as a workspace, not a tool. tools get replaced. workspaces compound.

[Veyra @Veyra_OS]

Why we built it

AI is moving fast. new models drop every few months. capabilities compound. what felt impossible last year is a base expectation now.

but the way most people interact with it hasn't changed. still one box, one response, one tab. the tools got smarter and the interface stayed the same.

we built VEYRA because the interface needs to catch up. as models get more capable, the limiting factor isn't what AI can do — it's how you orchestrate it. how you get multiple capabilities working together on the same problem. how you maintain context across a piece of work that has multiple stages. how you get from a goal to a finished output without manually doing the coordination yourself.

that's the gap. VEYRA is built to close it.

one workspace where specialists collaborate. where context flows between them. where your agents remember what they've learned about how you work. where the output is something you can actually use, not a conversation thread you have to interpret.

the models will keep getting better. the platform needs to be ready for that.

all being built in public : https://t.co/jOUkREj8zL

[Veyra @Veyra_OS]

VEYRA is a single workspace for AI work.

right now most people using AI are switching between tools constantly. ChatGPT for writing. Perplexity for research. Claude for analysis. a coding assistant for development. different tabs, different contexts, different outputs that
don't talk to each other. you're the one stitching it all together.

VEYRA is built around a different idea. one platform. specialist agents for every type of work — research, data analysis, growth strategy, code architecture, document production. each one deployed with real tools: live web search, cloud code execution, file management. each one with persistent memory that builds over time, so it gets better the more you use it.

you don't switch platforms depending on what you need to do. you open VEYRA and deploy the right specialist for the job.

we are building this from the ground up, you’re early :)

[Veyra @Veyra_OS]

shipped: mission templates - prep for release.

two files. one new, one updated - as shown in the earlier post.

services/mission_templates.py - five pre-built worker chains defined in code. Market Research, Competitor Analysis, Content Brief, Go-To-Market, Research Report. each template defines the groups, the workers, the exact sub-task per worker, and a {topic} placeholder that gets substituted at launch. no LLM call needed to plan the chain is already designed.

routers/missions.py — updated. create_mission now accepts an optional template_id. if present it resolves the template groups directly, substitutes the topic, and inserts the steps. if not, it falls back to the planner as before. one endpoint handles both paths.

missions isn't live yet — this is part of the build-out ahead of release. committing as we go, building in public.

https://t.co/OV3wyoeezv

https://t.co/QJRdWjw0tv

[Veyra @Veyra_OS]

one of the things we're building today for missions: templates.

the problem with a blank prompt box is that most people don't know how to structure a good mission objective. writing "research the EV market and give me a report" works — but you're not thinking about which workers to assign, what order they run in, what each one should specifically do, how context should flow between them. that's a lot of cognitive load before you've even started.

templates remove that entirely.

you pick the mission type — market research, competitor analysis, content brief, go-to-market strategy, research report — and all you type is the topic.

"Manchester Football Club." launch.

behind that single input: Deep Research Agent pulls data on the market, Data Analyst and Growth Hacker run in parallel scoring opportunities and building strategy, Admin Assistant compiles the final deliverable. the worker chain is pre-built, the handoffs are already designed, the context flow is already structured.

you didn't write any of that. you wrote two words.

that's the point. for common objectives the planning step is overhead. templates skip it entirely and go straight to execution with a proven chain.

custom missions are still there for when you want to define your own objective and let the planner build the chain from scratch. templates are for the work you already know you need to do.

pick a template. type a topic. run a coordinated workforce. so far so good, another part of missions ticked off today in preparation for release ✅

[Veyra @Veyra_OS]

the reason mission templates matter isn't convenience.

it's consistency.

when you run market research through a template, every run uses the same worker sequence, the same handoff structure, the same compression logic. outputs are comparable. you can run the same template on ten different markets and the results are structured the same way every time.

ad-hoc missions are powerful for new problems. templates are for the work you do repeatedly — competitor tracking, weekly briefs, research pipelines. build it once, run it whenever you need it.

that's the difference between a tool and a workflow.

more soon, happy sunday

[Veyra @Veyra_OS]

@2147_Million Thanks for the support once again, we will keep working :)

[Veyra @Veyra_OS]

gm. happy sunday.

big day ahead. missions is close — we're pushing to get it release-ready this week and today is heads down on the final pieces.

here's what's on the cards:

mission templates — pre-built worker chains for the most common objectives. market research, competitor analysis, content briefs. skip the planning step, launch instantly, get consistent structured output every time. one click to a full
coordinated workforce.

cost and token tracking — full visibility on what each mission run costs. every worker, every step, tokens used and dollar value surfaced in the UI. you should always know exactly what you're spending and where.

mission export — final deliverable as a structured document you can actually use. the whole point of running a mission is the output. export makes it portable.

mission replay — step back through any completed mission and see exactly what each worker did, what they found, what they passed forward. full audit trail. understand the output by understanding how it was built.

these aren't nice-to-haves. they're what takes missions from impressive demo to something you'd actually rely on week to week.

soon you'll be able to test this yourselves — we're getting close to opening it up. dropping progress throughout the day so stay tuned.

lots to build. let's get it.

[Veyra @Veyra_OS]

next up for VEYRA Missions: templates.

Right now every mission starts from scratch. you write a goal, the planner builds the worker chain, execution begins. that works — but for common objectives the planning step is redundant. market research looks roughly the same every time. so
does a competitor analysis. so does a content brief.

templates skip the planning step entirely. pre-built worker chains for the most common mission types, ready to launch with one click. you fill in the specifics, the chain is already designed.

less time configuring. more time on output.

[Veyra @Veyra_OS]

the code behind what you just watched.

the orchestrator is the core of it - each worker now runs as an independent asyncio task posting events to a shared queue.
the main loop drains that queue in real time so the SSE stream stays live across all parallel workers at once. when a
group completes, outputs are compressed and context is passed forward to the next group.

the router handles the group-aware step creation - steps that belong to the same parallel group share a step_order value.
the orchestrator groups by that value at runtime and decides what runs together vs what waits.

one goal in. parallel execution out. coordinated output forward.

https://t.co/fdm1IRxzoa

https://t.co/QJRdWjw0tv

[Veyra @Veyra_OS]

parallel worker lanes are now being worked into VEYRA Missions.

up until now, every worker has run one after another.

researcher finishes → analyst starts
analyst finishes → writer starts

clean flow, but not always the fastest.

because in a real mission, some workers don’t actually need to wait for each other.

so we’re building the planner to detect which steps are independent, group them together, and let those workers run at the same time.

same mission.
same sandbox.
same context feed.
multiple specialists working in parallel.

then once that group finishes, their outputs converge back into one shared context before the next stage begins.

instead of missions running like a straight line, they start to feel more like a real execution graph.

branch → work → merge → continue.

this matters because a lot of real-world objectives have parallel-able steps.

research might need to happen first, but after that, analysis, strategy, formatting, market mapping, or planning don’t always need to wait in a queue.

they can run together, then hand everything forward.

we’ve already hit some fun bugs getting this in:

worker cards sharing the same index
card states resetting mid-handoff
navigation breaking from one stray brace
completed steps visually reverting while the next group starts

all part of wiring something that actually runs live instead of just looking good in a diagram.

video shows the early version running.

[Veyra @Veyra_OS]

Missions Progress — VEYRA

what we've built so far:

✓ mission schema live in production — three tables: missions, mission_steps, mission_context. RLS-gated per user, full
audit trail per run
✓ auto-planner built — one sentence goal → Claude generates the full worker chain automatically. no drag and drop, no
configuration
✓ worker assignment logic — six specialist workers available: Deep Research, Data Analyst, Code Architect, Growth Hacker,
Admin Assistant, Technical Support. planner picks and sequences them based on the objective
✓ mission steps mapped and persisted — each step stored with order, assigned worker, specific sub-task, status, token
count, timestamps
✓ shared E2B sandbox — one live cloud container shared across all workers in the chain. boots in the background so workers
start immediately
✓ SSE streaming — full real-time event stream from backend to UI. every search, file write, handoff, and completion fires
as a live event
✓ handoff compression — worker outputs are distilled into structured packets before being passed forward. key findings,
decisions, artifacts, one-sentence brief. next worker gets signal only, not noise
✓ mission control UI — dark 3-column layout. live events feed, numbered worker pipeline, shared context panel, file
artifacts tree
✓ memory integration — workers read and write persistent user notes across sessions. missions make the memory richer over
time

current focus:

worker output quality and execution speed. compression is in — now making sure each worker produces tight, actionable
output within budget before passing the chain forward.

still to build:

→ parallel worker lanes — some steps don't depend on each other and should run simultaneously
→ mission templates — pre-built chains for common objectives (market research, competitor analysis, content briefs)
→ cost and token tracking per mission — full visibility on what each run costs
→ mission export — final deliverable as a structured document
→ mission replay — step back through any completed mission and see exactly what each worker did

this is where VEYRA stops being "agent chat" and starts being actual workforce orchestration. the difference is whether workers are just receiving prompts or genuinely building on each other's work.

[Veyra @Veyra_OS]

@SausTiramitam Thanks for the support.

[Veyra @Veyra_OS]

@2147_Million @usedecentralorg Thanks for the support :)

[Veyra @Veyra_OS]

The hard part with Missions isn’t the UI.

It’s deciding what gets passed between workers.

Too little context:
next worker is useless.

Too much context:
everything becomes noisy.

Today’s problem we had been working on:

turning messy worker output into clean handoff context. Pushed the fixed via our github today.

this was the current handoff. raw output, injected wholesale. works but it doesn't scale past 2-3 workers before the context becomes noise. next step: structured summaries, scored relevance, clean packets.

Next I’ll show you the changes in depth we made. All viewable via our github :

https://t.co/jOUkREj8zL

[Veyra @Veyra_OS]

shipped: handoff compression for VEYRA Missions.

this was the problem. each worker produces a full output - research dumps, analysis breakdowns, strategy docs. raw.
verbose. all of it was being injected wholesale into the next worker's system prompt.

it worked. but it didn't scale. three workers deep and the context is noise. the next worker is reading through 2000 words to find the 4 sentences that actually matter.

so i built a compression layer that sits between every handoff.

the moment a worker finishes, before anything is passed forward, a second inference call runs. its only job is to distil the raw output into a structured packet:

- key findings (max 5, facts only)
- decisions made
- artifacts produced
- one sentence brief for the next worker

that packet is what gets injected. not the full output. the next worker gets exactly what it needs to act, nothing else. the raw output is still saved to the database - full fidelity, always available - but it never pollutes the context chain.

the difference is whether workers are building on clean intelligence or wading through each other's thinking out loud.

this is what makes a workforce actually compound.

https://t.co/fdm1IRxzoa