Veyra

VeyraOS is now live on @Pumpfun Built for the future of autonomous AI workers. Official links: Website: veyraos.xyz GitHub: github.com/VeyraOS/Repo CA: 8KEkGxRBdwjHFXHFwiLQUidrqSD8BdsufEvnH45Ypump This is Day 1. From here, everything is about building.

cost and token tracking just shipped for VEYRA Missions. every mission run now surfaces exactly what it cost. per worker on the card as it completes, running total live in the header as the mission executes, and total cost on the mission card in your list when it's done. you write one objective. a coordinated workforce executes it. and at the end you know exactly what that workforce cost you — down to four decimal places. this matters because AI costs compound fast at scale. one mission might cost fractions of a cent. run fifty a week and you need visibility. we're building that in from the start, not as an afterthought. next up on the cost side: bring your own key. the plan is full BYO key support — log in with your own Anthropic key, OpenAI, Gemini, whatever engine you prefer. your key, your costs, billed directly to you. VEYRA becomes the orchestration layer, not the billing middleman. you pick the model, you control the spend. that's the direction. building it properly.

@RetardedNi85688 Hey there, it is already showing correct GitHub? Click the GitHub icon on the main page it should take you there

@Veyra_OS Hey bro can you update the website with the working github? That's would help lose some confusion github.com/VeyraOS/app

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.

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.

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.

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 : github.com/VeyraOS/app

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 :)

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. github.com/VeyraOS/app/bl… github.com/VeyraOS/app/bl…

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 ✅

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

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

List of unbonded projects I think are undervalued / likely bond. NFA DYOR. $VEYRA @Veyra_OS - 22K Was around 15K when I first mentioned it. Agent OS. Simple thesis: if agents keep becoming more useful, the operating layer around them becomes more important. $ATLAS @AtlasTreasuryOS - 17K First started talking about it around 10K and it has almost bonded twice already. AI-managed stablecoin with a treasury flywheel, yield mechanics, rules-based execution, and on-chain receipts. $DECENTRAL @usedecentralorg - 17K Was around 10K when I first started talking about it. Another decentralized AI inference project that has been consistently building for ~2 weeks now. $NUR @nurnetwork_ - 17K Was commenting on their posts around 10K asking questions, and some people may have frontrun. Protocol that lets people transact on Solana with USDC without needing to hold or buy SOL. Simple UX unlock. $BKIT @burnkitsdk - 15K Burn-powered checkout SDK for Solana tokens. Apps can accept any SPL token, burn a configurable share forever, route the rest to treasury, and issue verifiable receipts. Turns token burns from a chart gimmick into real utility rails for payments, marketplaces, gated tools, asset generation, creator apps, and more. BurnMarket is also coming soon, giving it a clear product path beyond just the SDK. $FABLE @fablecloudOS - 12K Deploy Fable agents that live on Solana and act on your behalf. Basically agent deployment with on-chain identity / execution. $0ICAI @ZeroicAI - 14K Agent-oriented programming in Rust. Modular multi-agent framework with BDI cognition, FIPA messaging, organizational patterns, and a supervised async runtime. Basically infra for building autonomous agent systems in safe Rust, with separate crates for core agent logic, messaging, cognition, patterns, and runtime. Also has Solana-facing product ideas around MEV arbitrage, threat detection, yield farming, and smart contract auditing. $WANEFI @Wane_Finance - 10K Deflation under staker sovereignty. Pumpfun creator fees flow into a keeper. 60% is hard-coded for buyback/burn and cannot be voted away. The remaining 40% is governed by stakers each epoch: burn more or pay SOL to stakers. Basically fee-backed deflation + holder-directed yield. None of these are guaranteed. But the common thread is simple: real product surface, active building, low market cap, and a narrative people can actually understand.

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.

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.

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. github.com/VeyraOS/app/bl… github.com/VeyraOS/app/bl…

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.

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.

@SausTiramitam Thanks for the support.

the dev working hard and still building for it it will bond soon $Veyra 8KEkGxRBdwjHFXHFwiLQUidrqSD8BdsufEvnH45Ypump 13k mc

@2147_Million @usedecentralorg Thanks for the support :)

Just going to point out some cool tech projects I see unbonded, of course $ATLAS is one of my favorites and I think will do extremely well: $DECENTRAL @usedecentralorg - another private AI / AI inference project with a stacked github and been building for about a week now. $VEYRA @Veyra_OS - Agent OS / Agent execution system. One of the best websites I've seen in my life. $SAGENT @AgentOS_Inc - probably the most slept on of the group. Insanely stacked git (on v6). In talks with African governments. With just one prompt, Super AgentOS complete tasks end to end on automation in the NL Studio or using the Workflow terminal or the Coding for manual developers.

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 : github.com/VeyraOS/app

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. github.com/VeyraOS/app/bl…